Which dog can your home legally have?

const norm = s => s.toLowerCase().replace(/[^a-z]/g, "");
const GENERIC = ["bulldog", "shepherd", "american", "english", "australian", ...D.hdb.flatMap(b => b.n.toLowerCase().split(/[^a-z]+/)).filter(w => w.length >= 4)];
const KEYS = [];
D.hdb.forEach(b => { [b.n, ...b.a, b.n.replace(/\s*\(.*\)/, "")].forEach(a => KEYS.push({k: norm(a), kind: "hdb", e: b})); });
D.spec.forEach(s => { [s.n, ...s.a].forEach(a => KEYS.push({k: norm(a), kind: "p" + s.p, e: s})); });
const MIXED = ["mix", "mongrel", "singaporespecial", "cross", "mutt"];
const CROSS_WORDS = ["cross", "crossbreed", "crossbred", "crossed", "mix", "mixed", "mixedbreed", "mongrel", "mutt", "x"];
const FILLER = ["breed", "dog", "singapore", "special", "local", "with", "and", "between", "a", "an", "the", "of", "or"];
const SIZES = ["standard", "giant", "medium", "moyen", "large", "intermediate", "heavy"];   // HDB lists only the small sizes of some breeds
function lookup(raw) {
  const key = norm(raw);
  if (key.length < 3) return {none: true, key};
  const words = raw.toLowerCase().split(/[^a-z]+/).filter(Boolean);
  if (MIXED.some(m => key.includes(m)) || words.some(w => CROSS_WORDS.includes(w))) {
    const rest = words.filter(w => !CROSS_WORDS.includes(w) && !FILLER.includes(w));   // the breed names next to the word "cross", if any
    const glued = rest.map(w => CROSS_WORDS.reduce((k, c) => c.length >= 3 ? k.split(c).join("") : k, w)).filter(Boolean).map(w => w.length > 5 && w.endsWith("s") ? w.slice(0, -1) : w);   // "Rottweilercross" -> "rottweiler", "Tosas" -> "tosa"
    const rk = glued.join("");
    if (["bulldog", "bulldogs"].includes(rk)) return {bulldog: true, key};
    const wins = [];   // every run of one to four words, as one key
    for (let i = 0; i < glued.length; i++) for (let j = i + 1; j <= Math.min(glued.length, i + 4); j++) wins.push(glued.slice(i, j).join(""));
    const SP = KEYS.filter(x => x.kind !== "hdb");
    let spec = SP.filter(x => wins.includes(x.k));   // 1. a whole name
    if (!spec.length) spec = SP.filter(x => x.k.length >= 5 && wins.some(w => w.includes(x.k)));   // 2. a longer phrase holding a name ("Rottweilers")
    if (!spec.length) for (const w of wins) {   // 3. part of one name ("Dogo", "Corso"); a word shared by several breeds ("Terrier") does not count
      const part = w.length >= 4 && !GENERIC.includes(w) ? SP.filter(x => x.k.includes(w)) : [];   // a single word that also names a listed breed ("Japanese", "Pinscher") or any bulldog or shepherd is too general
      if (new Set(part.map(x => x.e.n)).size === 1) { spec = part; break; }
    }
    if (spec.length) return {key, list: [spec[0]], k9: null, sizeOf: [], partial: false, cross: true};
    return {mixed: true, named: rest.length > 0, key};
  }
  if (key === "bulldog" || key === "bulldogs") return {bulldog: true, key};
  let hit = KEYS.filter(x => x.k === key), sizeOf = [];
  if (!hit.length) hit = KEYS.filter(x => x.k.length >= 5 && key.includes(x.k));
  if (hit.length && SIZES.some(w => key.includes(w)) && !KEYS.some(x => x.k === key)) { sizeOf = hit; hit = []; }
  let partial = false;
  if (!hit.length && !sizeOf.length && key.length >= 4) { hit = KEYS.filter(x => x.k.includes(key)); partial = hit.length > 0; }
  const seen = new Map(); hit.forEach(x => seen.set(x.kind + x.e.n, x));
  const list = [...seen.values()];
  const k9 = D.k9.find(b => norm(b).includes(key) || key.includes(norm(b)));
  return {key, list, k9, sizeOf, partial};
}