morphex 0.0.0-stage → 1.0.0

package/dist/rules.cjs

@@ -0,0 +1,1784 @@
+'use strict';
+
+/*! morphex — MIT code; bundled lexicon data is CC BY-SA 3.0 (Wiktionary contributors via Kaikki.org/Wiktextract). See NOTICE. */
+
+// src/compound-table.ts
+var COMPOUND_EXACT = {
+  "passer-by": "passers-by",
+  "hanger-on": "hangers-on",
+  "looker-on": "lookers-on",
+  "runner-up": "runners-up",
+  "stand-in": "stand-ins",
+  "drive-by": "drive-bys",
+  "tie-in": "tie-ins",
+  "close-up": "close-ups",
+  "grown-up": "grown-ups",
+  "go-between": "go-betweens",
+  "forget-me-not": "forget-me-nots",
+  "jack-in-the-box": "jack-in-the-boxes",
+  "man-of-war": "men-of-war",
+  "major general": "major generals"
+};
+var FREE_TAILS = [
+  "in-law",
+  "in-arms",
+  "in-aid",
+  "in-kind",
+  "in-chief",
+  "of-war",
+  "of-arms",
+  "of-spring",
+  "of-all-trades",
+  "out-law",
+  "at-arms",
+  "at-law",
+  "in-crime"
+];
+var POSTPOSED = [
+  "general",
+  "elect",
+  "apparent",
+  "designate",
+  "martial",
+  "laureate",
+  "presumptive",
+  "public",
+  "errant"
+];
+var CURATED_HEADS = [
+  "attorney",
+  "court",
+  "heir",
+  "notary",
+  "poet",
+  "governor",
+  "ambassador",
+  "president",
+  "mayor",
+  "minister",
+  "secretary",
+  "treasurer",
+  "surgeon",
+  "solicitor",
+  "lord",
+  "postmaster",
+  "editor",
+  "commander"
+];
+var PREPOSITIONS = [
+  "in",
+  "of",
+  "at",
+  "on",
+  "by",
+  "to",
+  "with",
+  "for",
+  "from",
+  "upon",
+  "under",
+  "over",
+  "into"
+];
+var NON_NOUN_HEADS = [
+  "known",
+  "born",
+  "bred",
+  "built",
+  "done",
+  "gone",
+  "held",
+  "left",
+  "lost",
+  "made",
+  "paid",
+  "sold",
+  "told",
+  "worn",
+  "written",
+  "spoken",
+  "taken",
+  "given",
+  "seen",
+  "heard",
+  "led",
+  "won",
+  "set",
+  "put",
+  "cut",
+  "read",
+  "run",
+  "come",
+  "become",
+  "beaten",
+  "broken",
+  "chosen",
+  "driven",
+  "eaten",
+  "fallen",
+  "forgotten",
+  "frozen",
+  "hidden",
+  "risen",
+  "shaken",
+  "shown",
+  "stolen",
+  "sworn",
+  "torn",
+  "woken",
+  "wrong",
+  "aware",
+  "alike",
+  "alone",
+  "asleep",
+  "awake"
+];
+var PARTICLES = [
+  "off",
+  "in",
+  "on",
+  "up",
+  "out",
+  "over",
+  "back",
+  "down",
+  "through",
+  "around",
+  "about",
+  "away"
+];
+var COORDINATORS = ["and", "or", "nor", "but", "the"];
+var COMPOUND_PREFIXES = ["on"];
+var MAN_EXCEPTIONS = [
+  "human",
+  "german",
+  "roman",
+  "shaman",
+  "talisman",
+  "caiman",
+  "ottoman",
+  "brahman",
+  "atman",
+  "liman",
+  "chroman",
+  "hooman",
+  "kundiman",
+  "laraman",
+  "oralman",
+  "abhuman",
+  "metahuman",
+  "paleohuman",
+  "parahuman",
+  "dragoman",
+  "firman",
+  "harman",
+  "tarman",
+  "turkman",
+  "touman",
+  "tramman",
+  "vataman",
+  "velociman",
+  "zygentoman"
+];
+var freeTailSet = new Set(FREE_TAILS);
+var postposedSet = new Set(POSTPOSED);
+var curatedHeadSet = new Set(CURATED_HEADS);
+var prepositionSet = new Set(PREPOSITIONS);
+var nonNounHeadSet = new Set(NON_NOUN_HEADS);
+var particleSet = new Set(PARTICLES);
+var coordinatorSet = new Set(COORDINATORS);
+var compoundPrefixSet = new Set(COMPOUND_PREFIXES);
+var manExceptionSet = new Set(MAN_EXCEPTIONS);
+function validateCompoundTable() {
+  for (const [key, plural] of Object.entries(COMPOUND_EXACT)) {
+    if (key !== key.toLowerCase() || plural !== plural.toLowerCase()) {
+      throw new Error(`compound table: exact entry must be lower case: ${key} -> ${plural}`);
+    }
+    if (!key.includes("-") && !key.includes(" ")) {
+      throw new Error(`compound table: exact entry must be a compound: ${key}`);
+    }
+  }
+  for (const tail of FREE_TAILS) {
+    if (!tail.includes("-") || tail.startsWith("-") || tail.endsWith("-") || tail !== tail.toLowerCase()) {
+      throw new Error(`compound table: malformed free tail: ${tail}`);
+    }
+  }
+  for (const token of [
+    ...POSTPOSED,
+    ...CURATED_HEADS,
+    ...PREPOSITIONS,
+    ...NON_NOUN_HEADS,
+    ...PARTICLES,
+    ...COORDINATORS,
+    ...COMPOUND_PREFIXES,
+    ...MAN_EXCEPTIONS
+  ]) {
+    if (token !== token.toLowerCase() || token.length === 0) {
+      throw new Error(`compound table: malformed token: ${token}`);
+    }
+  }
+  for (const token of [...POSTPOSED, ...CURATED_HEADS, ...PREPOSITIONS, ...COMPOUND_PREFIXES]) {
+    if (token.includes("-") || token.includes(" ")) {
+      throw new Error(`compound table: multi-token word in a word set: ${token}`);
+    }
+  }
+}
+validateCompoundTable();
+function exactPlural(lowerCase) {
+  return Object.prototype.hasOwnProperty.call(COMPOUND_EXACT, lowerCase) ? COMPOUND_EXACT[lowerCase] : void 0;
+}
+function isFreeTail(tailLower) {
+  return freeTailSet.has(tailLower);
+}
+function freeTailSuffix(lowerCase) {
+  let best = -1;
+  for (const tail of FREE_TAILS) {
+    const index = lowerCase.length - tail.length - 1;
+    if (index > 0 && index > best && lowerCase.charAt(index) === "-" && lowerCase.endsWith(tail)) {
+      best = index;
+    }
+  }
+  return best;
+}
+function isPostposed(tailLower) {
+  return postposedSet.has(tailLower);
+}
+function isCuratedHead(headLower) {
+  return curatedHeadSet.has(headLower);
+}
+function isPreposition(tokenLower) {
+  return prepositionSet.has(tokenLower);
+}
+function isNonNounHead(tokenLower) {
+  return nonNounHeadSet.has(tokenLower);
+}
+function isParticle(tokenLower) {
+  return particleSet.has(tokenLower);
+}
+function isManException(tokenLower) {
+  return manExceptionSet.has(tokenLower) || tokenLower.endsWith("human");
+}
+function isCoordinator(tokenLower) {
+  return coordinatorSet.has(tokenLower);
+}
+function isCompoundPrefix(tokenLower) {
+  return compoundPrefixSet.has(tokenLower);
+}
+
+// morphex-rules-only:empty-lexicon
+var BUNDLED_DELTA_LEXICON = "morphex-lexicon-v1	delta	0\n";
+
+// src/types.ts
+var INFLECTION_SOURCES = [
+  "OVERRIDE",
+  "LEXICON",
+  "INFERRED",
+  "COMPOUND",
+  "RULE",
+  "FALLBACK"
+];
+var COUNTABILITIES = ["COUNTABLE", "MASS", "MIXED", "PLURAL_ONLY", "UNKNOWN"];
+
+// src/word-shape.ts
+var LETTER = new RegExp("^\\p{L}$", "u");
+var LATIN_SCRIPT = new RegExp("^\\p{Script=Latin}$", "u");
+var NON_SPACING_MARK = new RegExp("^\\p{Mn}$", "u");
+function isAsciiLetterCodePoint(codePoint) {
+  return codePoint >= 65 && codePoint <= 90 || codePoint >= 97 && codePoint <= 122;
+}
+function isUpperCaseCodePoint(character) {
+  const upper = character.toUpperCase();
+  return upper === character && character.toLowerCase() !== character;
+}
+function lower(token) {
+  return hasUpper(token) ? token.toLowerCase() : token;
+}
+function hasUpper(token) {
+  for (const character of token) {
+    if (character.length === 1) {
+      const codePoint = character.charCodeAt(0);
+      if (codePoint >= 65 && codePoint <= 90) {
+        return true;
+      }
+      if (codePoint >= 128 && isUpperCaseCodePoint(character)) {
+        return true;
+      }
+    } else if (isUpperCaseCodePoint(character)) {
+      return true;
+    }
+  }
+  return false;
+}
+function casingOf(token) {
+  let anyUpper = false;
+  let anyLower = false;
+  let firstLetterIndex = -1;
+  let firstCodePoint = "";
+  let index = 0;
+  for (const character of token) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint < 128) {
+      if (codePoint >= 65 && codePoint <= 90) {
+        if (firstLetterIndex < 0) {
+          firstLetterIndex = index;
+          firstCodePoint = character;
+        }
+        anyUpper = true;
+      } else if (codePoint >= 97 && codePoint <= 122) {
+        if (firstLetterIndex < 0) {
+          firstLetterIndex = index;
+          firstCodePoint = character;
+        }
+        anyLower = true;
+      }
+    } else if (LETTER.test(character)) {
+      if (firstLetterIndex < 0) {
+        firstLetterIndex = index;
+        firstCodePoint = character;
+      }
+      if (isUpperCaseCodePoint(character)) {
+        anyUpper = true;
+      } else {
+        anyLower = true;
+      }
+    }
+    index += character.length;
+  }
+  if (!anyUpper) {
+    return "LOWER";
+  }
+  if (!anyLower) {
+    return "UPPER";
+  }
+  if (firstLetterIndex === 0 && isUpperCaseCodePoint(firstCodePoint)) {
+    return "CAPITALIZED";
+  }
+  return "MIXED";
+}
+function isPlainLatinToken(token) {
+  if (token.length === 0) {
+    return false;
+  }
+  let sawLetter = false;
+  for (const character of token) {
+    if (character.length === 1) {
+      const codePoint = character.charCodeAt(0);
+      if (codePoint < 128) {
+        if (!isAsciiLetterCodePoint(codePoint)) {
+          return false;
+        }
+        sawLetter = true;
+        continue;
+      }
+    }
+    if (LETTER.test(character) && LATIN_SCRIPT.test(character)) {
+      sawLetter = true;
+    } else if (!NON_SPACING_MARK.test(character)) {
+      return false;
+    }
+  }
+  return sawLetter;
+}
+function isAllUpperLatinToken(token) {
+  let letters = 0;
+  for (const character of token) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint < 128) {
+      if (codePoint < 65 || codePoint > 90) {
+        return false;
+      }
+    } else if (!LETTER.test(character) || !LATIN_SCRIPT.test(character)) {
+      return false;
+    } else if (!isUpperCaseCodePoint(character)) {
+      return false;
+    }
+    letters += 1;
+  }
+  return letters >= 2;
+}
+function codePointLength(token) {
+  let length = 0;
+  for (let index = 0; index < token.length; index += 1) {
+    if ((token.codePointAt(index) ?? 0) > 65535) {
+      index += 1;
+    }
+    length += 1;
+  }
+  return length;
+}
+function endsSibilant(lowerCase) {
+  const length = lowerCase.length;
+  if (length === 0) {
+    return false;
+  }
+  const last = lowerCase.charAt(length - 1);
+  if (last === "s" || last === "x" || last === "z") {
+    return true;
+  }
+  if (length >= 2) {
+    const previous = lowerCase.charAt(length - 2);
+    if ((previous === "c" || previous === "s") && last === "h") {
+      return true;
+    }
+  }
+  return false;
+}
+function endsConsonantY(lowerCase) {
+  const length = lowerCase.length;
+  if (length < 2 || lowerCase.charAt(length - 1) !== "y") {
+    return false;
+  }
+  const before = lowerCase.charAt(length - 2);
+  if (isAsciiVowel(before)) {
+    return before === "u" && length >= 3 && lowerCase.charAt(length - 3) === "q";
+  }
+  return true;
+}
+function isAsciiVowel(character) {
+  return character === "a" || character === "e" || character === "i" || character === "o" || character === "u";
+}
+function capitalize(token) {
+  if (token.length === 0) {
+    return token;
+  }
+  const first = token.codePointAt(0);
+  if (first === void 0) {
+    return token;
+  }
+  const character = String.fromCodePoint(first);
+  const upper = character.toUpperCase();
+  if (upper === character) {
+    return token;
+  }
+  return upper + token.slice(character.length);
+}
+
+// src/lexicon.ts
+var FULL_HEADER = "morphex-lexicon-v1";
+var DELTA_HEADER = "morphex-delta-v1";
+var RECORD_FIELDS = 8;
+var COUNTABILITY_CODES = {
+  COUNTABLE: "C",
+  MASS: "M",
+  MIXED: "X",
+  PLURAL_ONLY: "P",
+  UNKNOWN: "U"
+};
+var COUNTABILITY_BY_CODE = new Map(
+  COUNTABILITIES.map((countability) => [COUNTABILITY_CODES[countability], countability])
+);
+var FLAG_INVARIANT = 1;
+var FLAG_INITIALISM = 2;
+var FLAG_CASE_SENSITIVE = 4;
+var FLAG_AMBIGUOUS = 8;
+var NO_ALTERNATIVES = Object.freeze([]);
+function deriveEdit(lemma, plural) {
+  const max = Math.min(lemma.length, plural.length);
+  let prefix = 0;
+  while (prefix < max && lemma.charAt(prefix) === plural.charAt(prefix)) {
+    prefix += 1;
+  }
+  return [lemma.length - prefix, plural.slice(prefix)];
+}
+function reconstructPlural(lemma, cut, append) {
+  const end = Math.max(0, lemma.length - cut);
+  return lemma.slice(0, end) + append;
+}
+function binarySearch(keys, key) {
+  let low = 0;
+  let high = keys.length - 1;
+  while (low <= high) {
+    const middle = low + high >>> 1;
+    const candidate = keys[middle];
+    if (candidate === void 0) {
+      return -1;
+    }
+    if (candidate === key) {
+      return middle;
+    }
+    if (candidate < key) {
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return -1;
+}
+var TableLexicon = class {
+  kind;
+  size;
+  diagnostics = true;
+  #keys;
+  #entries;
+  #membership;
+  constructor(kind, keys, entries, membership) {
+    this.kind = kind;
+    this.size = entries.length;
+    this.#keys = keys;
+    this.#entries = entries;
+    this.#membership = membership;
+  }
+  lookup(key) {
+    const index = binarySearch(this.#keys, key);
+    return index < 0 ? void 0 : this.#entries[index];
+  }
+  isOrdinaryWord(key) {
+    return this.#membership?.contains(key);
+  }
+};
+var DELTA_KIND_MASS = -1;
+var DELTA_KIND_PLURAL_ONLY = -2;
+var DELTA_KIND_INVARIANT = -3;
+function hashDeltaKey(key) {
+  let hash = 2166136261;
+  for (let index = 0; index < key.length; index += 1) {
+    hash = Math.imul(hash ^ key.charCodeAt(index), 16777619);
+  }
+  return hash >>> 0;
+}
+function buildDeltaIndex(edits, massKeys, pluralOnlyKeys, invariantKeys) {
+  const total = edits.length + massKeys.length + pluralOnlyKeys.length + invariantKeys.length;
+  const keys = new Array(total);
+  const kinds = new Int32Array(total);
+  let capacity = 1;
+  while (capacity < total * 2) {
+    capacity *= 2;
+  }
+  const slots = new Uint32Array(capacity);
+  const mask = capacity - 1;
+  let position = 0;
+  const insert = (key, kind) => {
+    let slot = hashDeltaKey(key) & mask;
+    for (; ; ) {
+      const stored = slots[slot];
+      if (stored === void 0 || stored === 0) {
+        break;
+      }
+      if (keys[stored - 1] === key) {
+        throw new Error(`duplicate identity key '${key}'`);
+      }
+      slot = slot + 1 & mask;
+    }
+    keys[position] = key;
+    kinds[position] = kind;
+    slots[slot] = position + 1;
+    position += 1;
+  };
+  for (let index = 0; index < edits.length; index += 1) {
+    const entry = edits[index];
+    if (entry === void 0) {
+      throw new Error("delta artifact is missing an edit record");
+    }
+    insert(entry.key, index);
+  }
+  for (const key of massKeys) {
+    insert(key, DELTA_KIND_MASS);
+  }
+  for (const key of pluralOnlyKeys) {
+    insert(key, DELTA_KIND_PLURAL_ONLY);
+  }
+  for (const key of invariantKeys) {
+    insert(key, DELTA_KIND_INVARIANT);
+  }
+  if (position !== total) {
+    throw new Error("delta artifact index is shorter than its sections");
+  }
+  return { keys, kinds, slots, mask };
+}
+var DeltaLexicon = class {
+  kind = "delta";
+  size;
+  diagnostics = false;
+  #keys;
+  #kinds;
+  #slots;
+  #mask;
+  #edits;
+  #membership;
+  constructor(edits, massKeys, pluralOnlyKeys, invariantKeys, membership) {
+    this.#edits = edits;
+    const index = buildDeltaIndex(edits, massKeys, pluralOnlyKeys, invariantKeys);
+    this.#keys = index.keys;
+    this.#kinds = index.kinds;
+    this.#slots = index.slots;
+    this.#mask = index.mask;
+    this.size = edits.length + massKeys.length + pluralOnlyKeys.length + invariantKeys.length;
+    this.#membership = membership;
+  }
+  lookup(key) {
+    let slot = hashDeltaKey(key) & this.#mask;
+    for (; ; ) {
+      const stored = this.#slots[slot];
+      if (stored === void 0 || stored === 0) {
+        return void 0;
+      }
+      const position = stored - 1;
+      if (this.#keys[position] === key) {
+        const kind = this.#kinds[position];
+        if (kind === void 0) {
+          return void 0;
+        }
+        if (kind >= 0) {
+          return this.#edits[kind];
+        }
+        if (kind === DELTA_KIND_MASS) {
+          return identityEntry(key, "MASS", false);
+        }
+        if (kind === DELTA_KIND_PLURAL_ONLY) {
+          return identityEntry(key, "PLURAL_ONLY", false);
+        }
+        return identityEntry(key, "UNKNOWN", true);
+      }
+      slot = slot + 1 & this.#mask;
+    }
+  }
+  isOrdinaryWord(key) {
+    return this.#membership?.contains(key);
+  }
+};
+function identityEntry(key, countability, invariant) {
+  return Object.freeze({
+    lemma: key,
+    key,
+    plural: key,
+    classical: null,
+    alternatives: NO_ALTERNATIVES,
+    countability,
+    invariant,
+    initialism: false,
+    caseSensitive: false,
+    ambiguous: false
+  });
+}
+var RULES_ONLY_LEXICON = Object.freeze({
+  kind: "rules-only",
+  size: 0,
+  diagnostics: false,
+  lookup: () => void 0,
+  isOrdinaryWord: () => void 0
+});
+function parseRecord(record2, lineNumber) {
+  const fields = record2.split("	");
+  if (fields.length !== RECORD_FIELDS) {
+    throw new Error(
+      `lexicon line ${lineNumber}: expected ${RECORD_FIELDS} fields, found ${fields.length}`
+    );
+  }
+  const [lemmaField, cutField, appendField, classicalCutField, classicalAppendField] = fields;
+  const alternativesField = fields[5];
+  const countabilityField = fields[6];
+  const flagsField = fields[7];
+  if (lemmaField === void 0 || cutField === void 0 || appendField === void 0 || classicalCutField === void 0 || classicalAppendField === void 0 || alternativesField === void 0 || countabilityField === void 0 || flagsField === void 0) {
+    throw new Error(`lexicon line ${lineNumber}: malformed record`);
+  }
+  if (lemmaField.length === 0) {
+    throw new Error(`lexicon line ${lineNumber}: empty lemma`);
+  }
+  if (!/^\d+$/.test(cutField)) {
+    throw new Error(`lexicon line ${lineNumber}: bad cut '${cutField}'`);
+  }
+  const cut = Number.parseInt(cutField, 10);
+  if (!Number.isSafeInteger(cut) || cut > lemmaField.length) {
+    throw new Error(`lexicon line ${lineNumber}: cut ${cut} exceeds lemma length`);
+  }
+  if (!/^\d+$/.test(flagsField)) {
+    throw new Error(`lexicon line ${lineNumber}: bad flags '${flagsField}'`);
+  }
+  const flags = Number.parseInt(flagsField, 10);
+  if (flags < 0 || (flags & -16) !== 0) {
+    throw new Error(`lexicon line ${lineNumber}: unknown flags ${flags}`);
+  }
+  const countability = COUNTABILITY_BY_CODE.get(countabilityField);
+  if (countability === void 0) {
+    throw new Error(`lexicon line ${lineNumber}: bad countability '${countabilityField}'`);
+  }
+  let classical = null;
+  if (classicalCutField !== "-" || classicalAppendField !== "-") {
+    if (!/^\d+$/.test(classicalCutField)) {
+      throw new Error(`lexicon line ${lineNumber}: bad classical cut '${classicalCutField}'`);
+    }
+    const classicalCut = Number.parseInt(classicalCutField, 10);
+    if (classicalCut > lemmaField.length) {
+      throw new Error(`lexicon line ${lineNumber}: classical cut exceeds lemma length`);
+    }
+    classical = reconstructPlural(lemmaField, classicalCut, classicalAppendField);
+    if (classical.length === 0) {
+      throw new Error(`lexicon line ${lineNumber}: empty classical plural`);
+    }
+  }
+  let alternatives = NO_ALTERNATIVES;
+  if (alternativesField !== "-") {
+    const parsed = alternativesField.split(",");
+    if (parsed.some((alternative) => alternative.length === 0)) {
+      throw new Error(`lexicon line ${lineNumber}: empty alternative`);
+    }
+    alternatives = Object.freeze(parsed);
+  }
+  const plural = reconstructPlural(lemmaField, cut, appendField);
+  if (plural.length === 0) {
+    throw new Error(`lexicon line ${lineNumber}: empty plural`);
+  }
+  return Object.freeze({
+    lemma: lemmaField,
+    key: lower(lemmaField),
+    plural,
+    classical,
+    alternatives,
+    countability,
+    invariant: (flags & FLAG_INVARIANT) !== 0,
+    initialism: (flags & FLAG_INITIALISM) !== 0,
+    caseSensitive: (flags & FLAG_CASE_SENSITIVE) !== 0,
+    ambiguous: (flags & FLAG_AMBIGUOUS) !== 0
+  });
+}
+function parseEditRecords(lines, start, count, startLine) {
+  const entries = new Array(count);
+  let previousKey = null;
+  for (let offset = 0; offset < count; offset += 1) {
+    const record2 = lines[start + offset];
+    if (record2 === void 0 || record2.length === 0) {
+      throw new Error(`lexicon line ${startLine + offset}: missing record`);
+    }
+    const entry = parseRecord(record2, startLine + offset);
+    if (previousKey !== null && entry.key <= previousKey) {
+      throw new Error(
+        `lexicon line ${startLine + offset}: keys are not strictly ascending ('${entry.key}')`
+      );
+    }
+    previousKey = entry.key;
+    entries[offset] = entry;
+  }
+  return entries;
+}
+function parseKeyList(lines, start, count, startLine) {
+  const keys = new Array(count);
+  let previousKey = null;
+  for (let offset = 0; offset < count; offset += 1) {
+    const key = lines[start + offset];
+    if (key === void 0 || key.length === 0) {
+      throw new Error(`lexicon line ${startLine + offset}: empty identity key`);
+    }
+    if (key !== lower(key)) {
+      throw new Error(`lexicon line ${startLine + offset}: identity key is not lower case`);
+    }
+    if (previousKey !== null && key <= previousKey) {
+      throw new Error(`lexicon line ${startLine + offset}: identity keys are not ascending`);
+    }
+    previousKey = key;
+    keys[offset] = key;
+  }
+  return keys;
+}
+function parseFullLexicon(packed) {
+  const lines = packed.split("\n");
+  const headerLine = lines[0];
+  if (headerLine === void 0) {
+    throw new Error("lexicon artifact is empty");
+  }
+  const header = headerLine.split("	");
+  if (header.length !== 3 || header[0] !== FULL_HEADER || header[1] !== "full") {
+    throw new Error("lexicon artifact has an unknown header");
+  }
+  const reportedCount = Number.parseInt(header[2] ?? "", 10);
+  if (!Number.isSafeInteger(reportedCount) || reportedCount < 0) {
+    throw new Error("lexicon artifact has a bad entry count");
+  }
+  const records = [];
+  for (let index = 1; index < lines.length; index += 1) {
+    const record2 = lines[index];
+    if (record2 === void 0 || record2.length === 0) {
+      continue;
+    }
+    records.push(record2);
+  }
+  const entries = parseEditRecords(records, 0, records.length, 2);
+  if (entries.length !== reportedCount) {
+    throw new Error(
+      `lexicon artifact reports ${reportedCount} entries but contains ${entries.length}`
+    );
+  }
+  return entries;
+}
+function createFullLexicon(packed, membership) {
+  const entries = parseFullLexicon(packed);
+  return new TableLexicon(
+    "full",
+    entries.map((entry) => entry.key),
+    entries,
+    membership
+  );
+}
+function parseDeltaLexicon(packed) {
+  const lines = packed.split("\n");
+  const headerLine = lines[0];
+  if (headerLine === void 0) {
+    throw new Error("delta artifact is empty");
+  }
+  const header = headerLine.split("	");
+  if (header.length !== 5 || header[0] !== DELTA_HEADER) {
+    throw new Error("delta artifact has an unknown header");
+  }
+  const counts = header.slice(1).map((field) => Number.parseInt(field, 10));
+  if (counts.length !== 4 || counts.some((count) => !Number.isSafeInteger(count) || count < 0)) {
+    throw new Error("delta artifact has a bad section count");
+  }
+  const [editCount = -1, massCount = -1, pluralOnlyCount = -1, invariantCount = -1] = counts;
+  const expected = editCount + massCount + pluralOnlyCount + invariantCount;
+  const records = lines.length - 1;
+  const trailingEmptyLine = records > 0 && lines[lines.length - 1] === "";
+  if (records - (trailingEmptyLine ? 1 : 0) !== expected) {
+    throw new Error(
+      `delta artifact reports ${expected} records but contains ${records - (trailingEmptyLine ? 1 : 0)}`
+    );
+  }
+  const edits = parseEditRecords(lines, 1, editCount, 2);
+  let offset = 1 + editCount;
+  const massKeys = parseKeyList(lines, offset, massCount, 1 + offset);
+  offset += massCount;
+  const pluralOnlyKeys = parseKeyList(lines, offset, pluralOnlyCount, 1 + offset);
+  offset += pluralOnlyCount;
+  const invariantKeys = parseKeyList(lines, offset, invariantCount, 1 + offset);
+  return { edits, massKeys, pluralOnlyKeys, invariantKeys };
+}
+function createDeltaLexicon(packed, membership) {
+  const { edits, massKeys, pluralOnlyKeys, invariantKeys } = parseDeltaLexicon(packed);
+  return new DeltaLexicon(edits, massKeys, pluralOnlyKeys, invariantKeys, membership);
+}
+function normalizeInput(input, index) {
+  if (input.lemma.length === 0) {
+    throw new Error(`custom lexicon entry ${index}: lemma must be a non-empty string`);
+  }
+  if (input.plural.length === 0) {
+    throw new Error(`custom lexicon entry ${index}: plural must be a non-empty string`);
+  }
+  const alternatives = input.alternatives ?? [];
+  if (alternatives.some((alternative) => alternative.length === 0)) {
+    throw new Error(`custom lexicon entry ${index}: alternatives must be non-empty strings`);
+  }
+  return Object.freeze({
+    lemma: input.lemma,
+    key: lower(input.lemma),
+    plural: input.plural,
+    classical: input.classical ?? null,
+    alternatives: Object.freeze([...alternatives]),
+    countability: input.countability ?? "COUNTABLE",
+    invariant: input.invariant ?? false,
+    initialism: input.initialism ?? false,
+    caseSensitive: input.caseSensitive ?? false,
+    ambiguous: input.ambiguous ?? false
+  });
+}
+function createLexicon(entries, membership) {
+  const normalized = [];
+  let index = 0;
+  for (const input of entries) {
+    normalized.push(normalizeInput(input, index));
+    index += 1;
+  }
+  normalized.sort((left, right) => left.key < right.key ? -1 : left.key > right.key ? 1 : 0);
+  for (let position = 1; position < normalized.length; position += 1) {
+    const previous = normalized[position - 1];
+    const current = normalized[position];
+    if (previous !== void 0 && current !== void 0 && previous.key === current.key) {
+      throw new Error(`custom lexicon: duplicate lemma key '${current.key}'`);
+    }
+  }
+  return new TableLexicon(
+    "custom",
+    normalized.map((entry) => entry.key),
+    normalized,
+    membership
+  );
+}
+function fnv1aLow32(value) {
+  let hash = 2216829733;
+  const bytes = new TextEncoder().encode(value);
+  for (const byte of bytes) {
+    hash = Math.imul(hash ^ byte, 435) >>> 0;
+  }
+  return hash >>> 0;
+}
+function decodeBase64(value) {
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const clean = value.endsWith("==") ? value.slice(0, -2) : value.endsWith("=") ? value.slice(0, -1) : value;
+  const output = new Uint8Array(Math.floor(clean.length * 3 / 4));
+  let bits = 0;
+  let bitCount = 0;
+  let written = 0;
+  for (const character of clean) {
+    const digit = alphabet.indexOf(character);
+    if (digit < 0) {
+      throw new Error("invalid base64 lexicon data");
+    }
+    bits = bits << 6 | digit;
+    bitCount += 6;
+    if (bitCount >= 8) {
+      bitCount -= 8;
+      output[written] = bits >> bitCount & 255;
+      written += 1;
+      bits &= (1 << bitCount) - 1;
+    }
+  }
+  if (written !== output.length) {
+    throw new Error("truncated base64 lexicon data");
+  }
+  return output;
+}
+function createMembershipTable(base64) {
+  const bytes = decodeBase64(base64);
+  if (bytes.length % 4 !== 0) {
+    throw new Error("membership table length is not a multiple of four");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const hashes = new Uint32Array(bytes.length / 4);
+  for (let index = 0; index < hashes.length; index += 1) {
+    hashes[index] = view.getUint32(index * 4, true);
+  }
+  return {
+    size: hashes.length,
+    contains(value) {
+      const target = fnv1aLow32(value);
+      let low = 0;
+      let high = hashes.length - 1;
+      while (low <= high) {
+        const middle = low + high >>> 1;
+        const candidate = hashes[middle];
+        if (candidate === void 0) {
+          return false;
+        }
+        if (candidate === target) {
+          return true;
+        }
+        if (candidate < target) {
+          low = middle + 1;
+        } else {
+          high = middle - 1;
+        }
+      }
+      return false;
+    }
+  };
+}
+
+// src/defaults.ts
+var bundled;
+function defaultLexiconProvider() {
+  bundled ??= createDeltaLexicon(BUNDLED_DELTA_LEXICON);
+  return bundled;
+}
+
+// src/render.ts
+function edit(token, cut, append) {
+  const end = Math.max(0, token.length - cut);
+  if (append.length === 0) {
+    return end === token.length ? token : token.slice(0, end);
+  }
+  if (end === 0) {
+    return append;
+  }
+  return token.slice(0, end) + append;
+}
+function render(source, lowerCase, cut, append, policy) {
+  if (policy === "LOWERCASE") {
+    return edit(lowerCase, cut, append);
+  }
+  if (policy === "UPPERCASE") {
+    return edit(source, cut, append).toUpperCase();
+  }
+  const casing = casingOf(source);
+  if (casing === "LOWER") {
+    return edit(lowerCase, cut, append);
+  }
+  if (source.length !== lowerCase.length) {
+    const base = edit(lowerCase, cut, append);
+    if (casing === "UPPER") {
+      return base.toUpperCase();
+    }
+    if (casing === "CAPITALIZED") {
+      return capitalize(base);
+    }
+    return base;
+  }
+  const edited = edit(source, cut, append);
+  return casing === "UPPER" ? edited.toUpperCase() : edited;
+}
+function renderFull(source, lowerCase, fullLower, policy) {
+  if (policy === "LOWERCASE") {
+    return fullLower;
+  }
+  if (policy === "UPPERCASE") {
+    return fullLower.toUpperCase();
+  }
+  switch (casingOf(source)) {
+    case "LOWER":
+      return fullLower;
+    case "UPPER":
+      return fullLower.toUpperCase();
+    case "CAPITALIZED":
+      return capitalize(fullLower);
+    case "MIXED":
+      return fullLower.startsWith(lowerCase) ? source + fullLower.slice(lowerCase.length) : fullLower;
+    default:
+      return fullLower;
+  }
+}
+function renderInitialism(source, lowerCase, suffix, policy) {
+  if (policy === "LOWERCASE") {
+    return lowerCase + suffix;
+  }
+  if (policy === "UPPERCASE") {
+    return source.toUpperCase() + suffix.toUpperCase();
+  }
+  return source + suffix;
+}
+function applyCasePolicy(value, policy) {
+  if (policy === "LOWERCASE") {
+    return value.toLowerCase();
+  }
+  if (policy === "UPPERCASE") {
+    return value.toUpperCase();
+  }
+  return value;
+}
+
+// src/rules.ts
+function applyProductiveRule(noun, lowerCase) {
+  if (lowerCase.endsWith("woman")) {
+    return {
+      id: "backoff:woman->women",
+      cut: 5,
+      append: "women",
+      description: "documented -woman -> -women backoff"
+    };
+  }
+  if (lowerCase.endsWith("wife")) {
+    return {
+      id: "backoff:wife->wives",
+      cut: 4,
+      append: "wives",
+      description: "documented -wife -> -wives backoff"
+    };
+  }
+  if (lowerCase.length >= 6 && lowerCase.endsWith("man") && !lowerCase.endsWith("woman") && noun === lowerCase && !isManException(lowerCase)) {
+    return {
+      id: "backoff:man->men",
+      cut: 3,
+      append: "men",
+      description: "documented noun + man -> men backoff"
+    };
+  }
+  if (lowerCase.length >= 5 && lowerCase.endsWith("sis")) {
+    return {
+      id: "backoff:sis->ses",
+      cut: 2,
+      append: "es",
+      description: "documented Greek -sis -> -ses backoff"
+    };
+  }
+  if (endsSibilant(lowerCase)) {
+    return {
+      id: "rule:sibilant-es",
+      cut: 0,
+      append: "es",
+      description: "suffix s/x/z/ch/sh appends es"
+    };
+  }
+  if (endsConsonantY(lowerCase)) {
+    return {
+      id: "rule:consonant-y-ies",
+      cut: 1,
+      append: "ies",
+      description: "consonant before y becomes ies"
+    };
+  }
+  return {
+    id: "rule:default-s",
+    cut: 0,
+    append: "s",
+    description: "default appends s"
+  };
+}
+
+// src/english-inflector.ts
+var MAX_COMPOUND_DEPTH = 4;
+var FALLBACK_ID = "fallback:unsupported";
+var F_TO_VES = [
+  ["life", "lives"],
+  ["shelf", "shelves"],
+  ["half", "halves"],
+  ["staff", "staves"],
+  ["wolf", "wolves"],
+  ["leaf", "leaves"],
+  ["loaf", "loaves"],
+  ["calf", "calves"],
+  ["elf", "elves"],
+  ["self", "selves"],
+  ["thief", "thieves"],
+  ["sheaf", "sheaves"],
+  ["hoof", "hooves"]
+];
+function createSink() {
+  return {
+    stage: "FALLBACK",
+    id: FALLBACK_ID,
+    countability: "UNKNOWN",
+    invariant: false,
+    ambiguous: false,
+    alternatives: [],
+    note: ""
+  };
+}
+function record(sink, stage, id, countability, invariant, ambiguous, alternatives, note) {
+  sink.stage = stage;
+  sink.id = id;
+  sink.countability = countability;
+  sink.invariant = invariant;
+  sink.ambiguous = ambiguous;
+  sink.alternatives = alternatives;
+  sink.note = note;
+}
+var DiagnosticInflection = class {
+  input;
+  plural;
+  alternatives;
+  ambiguous;
+  stage;
+  source;
+  countability;
+  invariant;
+  note;
+  diagnostics;
+  constructor(fields) {
+    this.input = fields.input;
+    this.plural = fields.plural;
+    this.alternatives = Object.freeze([...fields.alternatives]);
+    this.ambiguous = fields.ambiguous;
+    this.stage = fields.stage;
+    this.source = fields.source;
+    this.countability = fields.countability;
+    this.invariant = fields.invariant;
+    this.note = fields.note;
+    this.diagnostics = fields.diagnostics;
+  }
+  isAccepted(form) {
+    return this.plural === form || this.alternatives.includes(form);
+  }
+};
+function entryNote(entry) {
+  switch (entry.countability) {
+    case "MASS":
+      return "mass noun: returned unchanged by policy";
+    case "PLURAL_ONLY":
+      return "plural-only lemma: returned unchanged by policy";
+    case "MIXED":
+      return "mixed mass/countable noun: pluralized in its countable sense";
+    default:
+      return entry.invariant ? "invariant plural: singular and plural are identical" : "";
+  }
+}
+function initialismSuffix(lowerCase) {
+  return lowerCase.charAt(lowerCase.length - 1) === "s" ? "es" : "s";
+}
+var standardInstance;
+var EnglishInflector = class _EnglishInflector {
+  #mode;
+  #casePolicy;
+  #overrides;
+  #initialisms;
+  #uppercasePolicy;
+  #lexicon;
+  /** @internal Instances are created through `standard()` or `builder()`. */
+  constructor(config) {
+    this.#mode = config.mode;
+    this.#casePolicy = config.casePolicy;
+    this.#overrides = config.overrides;
+    this.#initialisms = config.initialisms;
+    this.#uppercasePolicy = config.uppercasePolicy;
+    this.#lexicon = config.lexicon;
+  }
+  /** Shared default instance: anglicized mode, `PRESERVE` casing, bundled delta lexicon. */
+  static standard() {
+    standardInstance ??= _EnglishInflector.builder().build();
+    return standardInstance;
+  }
+  static builder() {
+    return new Builder();
+  }
+  get mode() {
+    return this.#mode;
+  }
+  get casePolicy() {
+    return this.#casePolicy;
+  }
+  get uppercasePolicy() {
+    return this.#uppercasePolicy;
+  }
+  /** Number of lexical entries visible to this instance (0 for a rules-only build). */
+  get lexiconSize() {
+    return this.#lexicon.size;
+  }
+  /**
+   * Returns the plural of a singular noun. With a `count`, returns `noun` unchanged when
+   * `count === 1` and the plural otherwise. This is deliberately a plain count test, not an
+   * absolute-value or locale rule.
+   */
+  pluralize(noun, count) {
+    if (count === 1) {
+      return noun;
+    }
+    return this.#resolve(noun, void 0, 0, this.#casePolicy);
+  }
+  /** Returns a full diagnostic result. The chosen form is identical to `pluralize(noun)`. */
+  analyze(noun) {
+    const sink = createSink();
+    const plural = this.#resolve(noun, sink, 0, this.#casePolicy);
+    return new DiagnosticInflection({
+      input: noun,
+      plural,
+      alternatives: sink.alternatives,
+      ambiguous: sink.ambiguous,
+      stage: sink.stage,
+      source: sink.id,
+      countability: sink.countability,
+      invariant: sink.invariant,
+      note: sink.note,
+      diagnostics: this.#lexicon.diagnostics
+    });
+  }
+  // ------------------------------------------------------------------ resolution
+  #resolve(noun, sink, depth, policy) {
+    if (noun.length === 0) {
+      if (sink !== void 0) {
+        record(
+          sink,
+          "FALLBACK",
+          "fallback:empty",
+          "UNKNOWN",
+          false,
+          false,
+          [],
+          "empty input returns empty output"
+        );
+      }
+      return noun;
+    }
+    const override = this.#overrides.get(noun);
+    if (override !== void 0) {
+      if (sink !== void 0) {
+        record(
+          sink,
+          "OVERRIDE",
+          "override",
+          "UNKNOWN",
+          false,
+          false,
+          [],
+          "caller override matched the exact input spelling"
+        );
+      }
+      return override;
+    }
+    const lowerCase = lower(noun);
+    const entry = this.#lexicon.lookup(lowerCase);
+    if (entry !== void 0 && (!entry.caseSensitive || entry.lemma === noun)) {
+      return this.#fromEntry(noun, lowerCase, entry, sink, policy);
+    }
+    if (this.#initialisms.has(lowerCase)) {
+      if (sink !== void 0) {
+        record(
+          sink,
+          "LEXICON",
+          "config:initialism",
+          "UNKNOWN",
+          false,
+          false,
+          [],
+          "token declared an initialism by configuration"
+        );
+      }
+      return renderInitialism(noun, lowerCase, initialismSuffix(lowerCase), policy);
+    }
+    const ordinaryWord = this.#lexicon.isOrdinaryWord(lowerCase);
+    if (this.#uppercasePolicy === "INFER_INITIALISM" && this.#lexicon.size > 0 && ordinaryWord !== void 0 && !ordinaryWord && isAllUpperLatinToken(noun) && codePointLength(noun) >= 2 && codePointLength(noun) <= 6) {
+      if (sink !== void 0) {
+        record(
+          sink,
+          "INFERRED",
+          "inferred:uppercase-initialism",
+          "UNKNOWN",
+          false,
+          false,
+          [],
+          "unknown all-upper-case token of 2-6 Latin letters: appended lower-case s; lexical membership was checked first"
+        );
+      }
+      return renderInitialism(noun, lowerCase, "s", policy);
+    }
+    if (depth < MAX_COMPOUND_DEPTH && (noun.includes("-") || noun.includes(" "))) {
+      const compound = this.#resolveCompound(noun, lowerCase, depth, policy, sink);
+      if (compound !== null) {
+        return compound === noun ? noun : compound;
+      }
+    }
+    if (isPlainLatinToken(noun)) {
+      const rule = applyProductiveRule(noun, lowerCase);
+      if (sink !== void 0) {
+        record(sink, "RULE", rule.id, "UNKNOWN", false, false, [], rule.description);
+      }
+      return render(noun, lowerCase, rule.cut, rule.append, policy);
+    }
+    if (sink !== void 0) {
+      record(
+        sink,
+        "FALLBACK",
+        FALLBACK_ID,
+        "UNKNOWN",
+        false,
+        false,
+        [],
+        "unsupported token shape (identifier, punctuation, possessive or non-Latin letter); returned unchanged"
+      );
+    }
+    return noun;
+  }
+  #fromEntry(noun, lowerCase, entry, sink, policy) {
+    const [cut, append] = deriveEdit(entry.lemma, entry.plural);
+    if (entry.initialism) {
+      if (sink !== void 0) {
+        record(
+          sink,
+          "LEXICON",
+          `lex:${entry.caseSensitive ? entry.lemma : entry.key}#initialism`,
+          entry.countability,
+          false,
+          entry.ambiguous,
+          [],
+          "initialism metadata: append the entry's s/es suffix without whole-token re-casing"
+        );
+      }
+      return renderInitialism(noun, lowerCase, append, policy);
+    }
+    if (entry.countability === "MASS" || entry.countability === "PLURAL_ONLY" || entry.invariant) {
+      if (sink !== void 0) {
+        record(
+          sink,
+          "LEXICON",
+          `lex:${entry.caseSensitive ? entry.lemma : entry.key}`,
+          entry.countability,
+          entry.invariant,
+          entry.ambiguous,
+          this.#renderAlternatives(noun, lowerCase, entry, false, policy),
+          entryNote(entry)
+        );
+      }
+      return noun;
+    }
+    const classicalForm = this.#mode === "CLASSICAL" ? entry.classical : null;
+    const classicalUsed = classicalForm !== null;
+    let pluralCut = cut;
+    let pluralAppend = append;
+    if (classicalForm !== null) {
+      [pluralCut, pluralAppend] = deriveEdit(entry.lemma, classicalForm);
+    }
+    const plural = render(noun, lowerCase, pluralCut, pluralAppend, policy);
+    if (sink !== void 0) {
+      record(
+        sink,
+        "LEXICON",
+        `lex:${entry.caseSensitive ? entry.lemma : entry.key}`,
+        entry.countability,
+        false,
+        entry.ambiguous,
+        this.#renderAlternatives(noun, lowerCase, entry, classicalUsed, policy),
+        classicalUsed ? "classical preference selected by mode" : entryNote(entry)
+      );
+    }
+    return plural;
+  }
+  #renderAlternatives(noun, lowerCase, entry, classicalUsed, policy) {
+    const stored = entry.alternatives;
+    const classical = entry.classical;
+    if (stored.length === 0 && classical === null) {
+      return [];
+    }
+    const alternatives = [];
+    if (classicalUsed) {
+      alternatives.push(renderFull(noun, lowerCase, entry.plural, policy));
+    } else if (classical !== null) {
+      alternatives.push(renderFull(noun, lowerCase, classical, policy));
+    }
+    for (const alternative of stored) {
+      alternatives.push(renderFull(noun, lowerCase, alternative, policy));
+    }
+    return alternatives;
+  }
+  // ------------------------------------------------------------------ compounds
+  #resolveCompound(noun, lowerCase, depth, policy, sink) {
+    const exact = exactPlural(lowerCase);
+    if (exact !== void 0) {
+      if (sink !== void 0) {
+        record(
+          sink,
+          "COMPOUND",
+          `compound:exact:${lowerCase}`,
+          "UNKNOWN",
+          false,
+          false,
+          [],
+          "exact compound entry"
+        );
+      }
+      return renderFull(noun, lowerCase, exact, policy);
+    }
+    const freeSuffix = freeTailSuffix(lowerCase);
+    if (freeSuffix > 0 && freeSuffix < noun.length) {
+      const headPlural = this.#resolveHead(noun.slice(0, freeSuffix), depth, true);
+      if (headPlural !== null) {
+        if (sink !== void 0) {
+          record(
+            sink,
+            "COMPOUND",
+            "compound:hyphen:free-tail-suffix",
+            "UNKNOWN",
+            false,
+            false,
+            [],
+            "documented trailing free tail: head before the suffix is inflected"
+          );
+        }
+        return applyCasePolicy(headPlural.text + noun.slice(freeSuffix), policy);
+      }
+    }
+    const hyphen = noun.indexOf("-");
+    if (hyphen > 0 && hyphen < noun.length - 1) {
+      const head = noun.slice(0, hyphen);
+      const tail = lowerCase.slice(hyphen + 1);
+      const recognised = isFreeTail(tail) || isPostposed(tail) && isCuratedHead(lower(head));
+      if (recognised) {
+        const headPlural = this.#resolveHead(head, depth);
+        if (headPlural !== null) {
+          if (sink !== void 0) {
+            record(
+              sink,
+              "COMPOUND",
+              `compound:hyphen:${tail}`,
+              "UNKNOWN",
+              false,
+              false,
+              [],
+              `documented hyphenated compound pattern '${tail}'`
+            );
+          }
+          return applyCasePolicy(headPlural.text + noun.slice(hyphen), policy);
+        }
+      }
+      if (this.#isParticleCompound(noun, hyphen, tail)) {
+        if (sink !== void 0) {
+          record(
+            sink,
+            "COMPOUND",
+            "compound:hyphen:particle",
+            "UNKNOWN",
+            false,
+            false,
+            [],
+            "verb-particle hyphenated noun: whole expression takes s"
+          );
+        }
+        return render(noun, lowerCase, 0, "s", policy);
+      }
+      if (this.#isHeadFinalCompound(noun, hyphen, tail)) {
+        const tailPlural = this.#pluralizeCompoundHead(noun.slice(hyphen + 1), depth, true);
+        if (tailPlural !== null) {
+          if (sink !== void 0) {
+            record(
+              sink,
+              "COMPOUND",
+              "compound:hyphen:head-final",
+              "UNKNOWN",
+              false,
+              false,
+              [],
+              "head-final hyphenated compound: final noun head inflected"
+            );
+          }
+          return applyCasePolicy(noun.slice(0, hyphen + 1) + tailPlural, policy);
+        }
+      }
+      const lastHyphen = noun.lastIndexOf("-");
+      if (lastHyphen > hyphen && this.#isMultiHeadFinalCompound(noun)) {
+        const multiTail = noun.slice(lastHyphen + 1);
+        const tailPlural = this.#pluralizeCompoundHead(multiTail, depth, true);
+        if (tailPlural !== null) {
+          if (sink !== void 0) {
+            record(
+              sink,
+              "COMPOUND",
+              "compound:hyphen:multi-head-final",
+              "UNKNOWN",
+              false,
+              false,
+              [],
+              "multi-hyphen head-final noun without a function word: final head inflected"
+            );
+          }
+          return applyCasePolicy(noun.slice(0, lastHyphen + 1) + tailPlural, policy);
+        }
+      }
+      return null;
+    }
+    const space = noun.indexOf(" ");
+    if (space < 0 || space === 0 || space === noun.length - 1 || noun.includes("  ")) {
+      return null;
+    }
+    const tokens = noun.split(" ");
+    if (tokens.length < 2 || tokens.some((token) => token.length === 0)) {
+      return null;
+    }
+    const lastToken = tokens[tokens.length - 1];
+    if (lastToken === void 0) {
+      return null;
+    }
+    const lastLower = lower(lastToken);
+    if (isPostposed(lastLower)) {
+      const headLower = tokens.slice(0, -1).map((token) => lower(token)).join(" ");
+      if (isCuratedHead(headLower)) {
+        const headPlural = this.#resolveHead(noun.slice(0, space), depth);
+        if (headPlural !== null) {
+          if (sink !== void 0) {
+            record(
+              sink,
+              "COMPOUND",
+              `compound:space:${lastLower}`,
+              "UNKNOWN",
+              false,
+              false,
+              [],
+              `postposed modifier '${lastLower}' after a curated head`
+            );
+          }
+          return applyCasePolicy(headPlural.text + noun.slice(space), policy);
+        }
+      }
+    }
+    if (tokens.some((token) => isPreposition(lower(token)))) {
+      return null;
+    }
+    if (!isPlainLatinToken(lastToken)) {
+      return null;
+    }
+    const lastPlural = this.#pluralizeCompoundHead(lastToken, depth, false);
+    if (lastPlural === null) {
+      return null;
+    }
+    if (sink !== void 0) {
+      record(
+        sink,
+        "COMPOUND",
+        "compound:space:final",
+        "UNKNOWN",
+        false,
+        false,
+        [],
+        "space-separated compound: final token inflected"
+      );
+    }
+    const lastStart = noun.length - lastToken.length;
+    return applyCasePolicy(noun.slice(0, lastStart) + lastPlural, policy);
+  }
+  #resolveHead(head, depth, allowCompoundShape = false) {
+    if (depth >= MAX_COMPOUND_DEPTH || head.length === 0) {
+      return null;
+    }
+    if (!allowCompoundShape && !isPlainLatinToken(head)) {
+      return null;
+    }
+    const headSink = createSink();
+    const text = this.#resolve(head, headSink, depth + 1, "PRESERVE");
+    if (headSink.stage === "FALLBACK") {
+      return null;
+    }
+    return {
+      text,
+      stage: headSink.stage,
+      id: headSink.id,
+      invariant: headSink.invariant
+    };
+  }
+  #pluralizeCompoundHead(head, depth, allowRespell) {
+    const resolved = this.#resolveHead(head, depth);
+    if (resolved === null) {
+      return null;
+    }
+    if (allowRespell && this.#shouldRespell(resolved, head)) {
+      return this.#spellHead(head, "PRESERVE");
+    }
+    return resolved.text;
+  }
+  #shouldRespell(resolved, head) {
+    if (resolved.stage !== "RULE") {
+      return false;
+    }
+    const lowerCase = lower(head);
+    return this.#lexicon.isOrdinaryWord(lowerCase) !== true;
+  }
+  #spellHead(head, policy) {
+    if (!isPlainLatinToken(head)) {
+      return null;
+    }
+    const lowerCase = lower(head);
+    if (lowerCase.endsWith("child")) {
+      return render(head, lowerCase, 5, "children", policy);
+    }
+    for (const [singular, plural] of F_TO_VES) {
+      if (lowerCase.endsWith(singular)) {
+        return render(head, lowerCase, singular.length, plural, policy);
+      }
+    }
+    const rule = applyProductiveRule(head, lowerCase);
+    return render(head, lowerCase, rule.cut, rule.append, policy);
+  }
+  /**
+   * Admission policy for the generic head-final hyphenated compound path. Exactly one separator,
+   * both tokens plain Latin words, a multi-letter final token, no preposition, and a documented
+   * non-noun head exclusion.
+   */
+  #isHeadFinalCompound(noun, hyphen, tailLower) {
+    if (hyphen !== noun.lastIndexOf("-")) {
+      return false;
+    }
+    const head = noun.slice(0, hyphen);
+    const tail = noun.slice(hyphen + 1);
+    if (!isPlainLatinToken(head) || !isPlainLatinToken(tail)) {
+      return false;
+    }
+    if (codePointLength(head) < 1 || codePointLength(tail) < 2) {
+      return false;
+    }
+    return !(isNonNounHead(tailLower) || isPreposition(lower(head)) && !isCompoundPrefix(lower(head)) || isPreposition(tailLower) || isFreeTail(tailLower));
+  }
+  /** Multi-hyphen modifier chains ending in a noun head, with no preposition/coordinator. */
+  #isMultiHeadFinalCompound(noun) {
+    const tokens = noun.split("-");
+    if (tokens.length < 3) {
+      return false;
+    }
+    for (const token of tokens) {
+      if (!isPlainLatinToken(token) || codePointLength(token) < 1) {
+        return false;
+      }
+    }
+    for (let index = 0; index < tokens.length - 1; index += 1) {
+      const token = tokens[index];
+      if (token === void 0) {
+        return false;
+      }
+      const tokenLower = lower(token);
+      if (isPreposition(tokenLower) || isCoordinator(tokenLower)) {
+        return false;
+      }
+    }
+    const last = tokens[tokens.length - 1];
+    if (last === void 0) {
+      return false;
+    }
+    const tailLower = lower(last);
+    return !isPreposition(tailLower) && !isNonNounHead(tailLower) && !isCoordinator(tailLower);
+  }
+  /** A single-hyphen verb-particle noun such as `bake-off` or `blow-in`. */
+  #isParticleCompound(noun, hyphen, tailLower) {
+    if (hyphen !== noun.lastIndexOf("-") || !isParticle(tailLower)) {
+      return false;
+    }
+    const head = noun.slice(0, hyphen);
+    const tail = noun.slice(hyphen + 1);
+    return isPlainLatinToken(head) && isPlainLatinToken(tail) && codePointLength(head) >= 1 && codePointLength(tail) >= 2;
+  }
+};
+var Builder = class {
+  #mode = "ANGLICIZED";
+  #casePolicy = "PRESERVE";
+  #overrides = /* @__PURE__ */ new Map();
+  #initialisms = /* @__PURE__ */ new Set();
+  #uppercasePolicy = "INFER_INITIALISM";
+  #lexicon;
+  withMode(mode) {
+    this.#mode = mode;
+    return this;
+  }
+  withCasePolicy(casePolicy) {
+    this.#casePolicy = casePolicy;
+    return this;
+  }
+  withUppercasePolicy(uppercasePolicy) {
+    this.#uppercasePolicy = uppercasePolicy;
+    return this;
+  }
+  /** Adds an exact, case-sensitive replacement for the whole input spelling. */
+  withOverride(noun, plural) {
+    if (noun.length === 0) {
+      throw new Error("override key must not be empty");
+    }
+    this.#overrides.set(noun, plural);
+    return this;
+  }
+  withOverrides(replacements) {
+    for (const [noun, plural] of Object.entries(replacements)) {
+      this.withOverride(noun, plural);
+    }
+    return this;
+  }
+  /** Declares a token an initialism: it appends `s`, or `es` after a final s. */
+  withInitialism(token) {
+    if (token.length === 0) {
+      throw new Error("initialism token must not be empty");
+    }
+    this.#initialisms.add(lower(token));
+    return this;
+  }
+  withInitialisms(tokens) {
+    for (const token of tokens) {
+      this.withInitialism(token);
+    }
+    return this;
+  }
+  /** Replaces the bundled lexicon with caller-supplied or custom data. */
+  withLexicon(lexicon) {
+    this.#lexicon = lexicon;
+    return this;
+  }
+  /** Builds a rules-only instance (no bundled lexicon). */
+  withoutBundledLexicon() {
+    this.#lexicon = RULES_ONLY_LEXICON;
+    return this;
+  }
+  build() {
+    return new EnglishInflector({
+      mode: this.#mode,
+      casePolicy: this.#casePolicy,
+      overrides: new Map(this.#overrides),
+      initialisms: new Set(this.#initialisms),
+      uppercasePolicy: this.#uppercasePolicy,
+      lexicon: this.#lexicon ?? defaultLexiconProvider()
+    });
+  }
+};
+
+exports.Builder = Builder;
+exports.COMPOUND_EXACT = COMPOUND_EXACT;
+exports.COUNTABILITIES = COUNTABILITIES;
+exports.EnglishInflector = EnglishInflector;
+exports.INFLECTION_SOURCES = INFLECTION_SOURCES;
+exports.RULES_ONLY_LEXICON = RULES_ONLY_LEXICON;
+exports.createDeltaLexicon = createDeltaLexicon;
+exports.createFullLexicon = createFullLexicon;
+exports.createLexicon = createLexicon;
+exports.createMembershipTable = createMembershipTable;
+exports.decodeBase64 = decodeBase64;
+exports.defaultLexiconProvider = defaultLexiconProvider;
+exports.deriveEdit = deriveEdit;
+exports.fnv1aLow32 = fnv1aLow32;
+exports.parseFullLexicon = parseFullLexicon;
+exports.validateCompoundTable = validateCompoundTable;
+//# sourceMappingURL=rules.cjs.map
+//# sourceMappingURL=rules.cjs.map