tonus 0.1.0

package/dist/engines/chant/ordinary.js

@@ -0,0 +1,232 @@
+// ---------------------------------------------------------------------------
+// engines/chant/ordinary — Mass ordinary (kyriale) selection
+// ---------------------------------------------------------------------------
+import { MASSES, AD_LIB } from "../../data/masses.js";
+import { KYRIALE } from "../../data/kyriale.js";
+import { MODE_LABELS, ORDINARY_LABELS, } from "./types.js";
+import { gradeOrder, PENITENTIAL_SEASONS, } from "../cal/types.js";
+// A "high feast" (Duplex II classis or above) prefers the solemn kyriale
+// masses 1–9. Threshold expressed against GRADE_ORDER, not a magic number.
+function isHighFeast(grade) {
+    return gradeOrder(grade) <= gradeOrder("duplex-ii");
+}
+const ORDINARY_OFFICES = new Set(Object.keys(ORDINARY_LABELS));
+const MODE_PAIRS = [[1, 2], [3, 4], [5, 6], [7, 8]];
+const CREDO_PRIORITY = ["IV", "III", "I", "II", "V", "VI"];
+function pairedMode(mode) {
+    const pair = MODE_PAIRS.find((p) => p.includes(mode));
+    return pair ? (pair.find((m) => m !== mode) ?? null) : null;
+}
+function resolveMasses(feast) {
+    const resolved = feast.masses
+        .map((num) => MASSES.get(num) ?? null)
+        .filter((m) => m !== null);
+    if (resolved.length)
+        return resolved;
+    return [feast.marian ? AD_LIB.bvm : AD_LIB.standard];
+}
+function entriesForOffice(office, massNumbers) {
+    const byMass = KYRIALE.filter((e) => e.office === office && e.mass != null && massNumbers.includes(e.mass));
+    if (byMass.length)
+        return byMass;
+    return KYRIALE.filter((e) => e.office === office && e.mass == null);
+}
+function selectBestChant(entries, filterMode, highFeast, massNumbers) {
+    if (!entries.length)
+        return null;
+    const modeStr = filterMode != null ? String(filterMode) : null;
+    let candidates = modeStr
+        ? entries.filter((e) => e.mode === modeStr)
+        : entries;
+    if (!candidates.length && modeStr) {
+        const paired = pairedMode(filterMode);
+        if (paired)
+            candidates = entries.filter((e) => e.mode === String(paired));
+    }
+    if (!candidates.length)
+        candidates = entries;
+    if (highFeast && candidates.length > 1) {
+        const preferred = candidates.filter((c) => c.mass != null && c.mass >= 1 && c.mass <= 9);
+        if (preferred.length)
+            candidates = preferred;
+    }
+    return candidates[0];
+}
+function allowedCredos(masses) {
+    const set = new Set();
+    for (const m of masses)
+        for (const c of m.credos)
+            set.add(c);
+    return CREDO_PRIORITY.filter((c) => set.has(c));
+}
+function selectCredoCode(feast, allowed) {
+    if (!allowed.length)
+        return null;
+    const { season, weekday, marian, apostolic } = feast;
+    const isSunday = weekday === 0;
+    if (isSunday && ["adv", "quadp", "quad", "nat"].includes(season) && allowed.includes("IV"))
+        return "IV";
+    if (isSunday && season === "pasc" && allowed.includes("III"))
+        return "III";
+    if (isSunday && ["epi", "pent"].includes(season) && allowed.includes("I"))
+        return "I";
+    if (apostolic && allowed.includes("III"))
+        return "III";
+    if (marian && allowed.includes("IV"))
+        return "IV";
+    return allowed[0];
+}
+function entryToOrdinaryChant(entry) {
+    const ordinary = ORDINARY_OFFICES.has(entry.office)
+        ? entry.office
+        : "ky";
+    return {
+        id: entry.id,
+        incipit: entry.incipit,
+        gabc: entry.gabc,
+        office: "or",
+        genus: "Ordinarium",
+        mode: entry.mode ? String(entry.mode) : null,
+        modus: entry.mode ? (MODE_LABELS[String(entry.mode)] ?? null) : null,
+        pages: [],
+        source: { book: "Graduale Romanum", year: 1961, editor: "Solesmes", code: "gr" },
+        ordinary,
+        ordinarium: ORDINARY_LABELS[ordinary] ?? entry.incipit,
+        mass: entry.mass ?? 0,
+    };
+}
+// Maundy Thursday (In Cena Domini) is a Triduum exception: it retains a full
+// Mass with the Gloria (rung with bells, which then fall silent until the
+// Easter Vigil) despite Lent's penitential omission and the Triduum's
+// otherwise empty ordinary. The Credo and the Sunday sprinkle rite are not
+// part of this evening Mass. See docs/chant.md.
+const MAUNDY_THURSDAY_ID = "Quad6-4";
+// The feast carries no numbered Kyriale mass of its own (masses: []); as a
+// paschally-adjacent solemnity it draws on Mass I (Lux et origo) — the same
+// mass the Easter Vigil borrows, so both Triduum Masses share a setting.
+const MAUNDY_THURSDAY_MASS = 1;
+function ordinaryForFeast(feast, pinMass, filterMode) {
+    const isMaundyThursday = feast.id === MAUNDY_THURSDAY_ID;
+    // The Triduum has no Mass-ordinary cycle (Good Friday has no Mass; the
+    // Vigil's ordinary belongs to Easter). Maundy Thursday is the exception —
+    // it keeps its Mass. An explicitly pinned mass also overrides.
+    if (feast.grade === "triduum" && pinMass == null && !isMaundyThursday)
+        return [];
+    const resolvedMass = pinMass ?? (isMaundyThursday ? MAUNDY_THURSDAY_MASS : undefined);
+    const masses = resolvedMass != null
+        ? (() => { const e = MASSES.get(resolvedMass); return e ? [e] : []; })()
+        : resolveMasses(feast);
+    const massNumbers = masses.map((m) => m.mass);
+    const mode = filterMode ?? null;
+    const highFeast = isHighFeast(feast.grade);
+    const pick = (office) => {
+        const entries = entriesForOffice(office, massNumbers);
+        const best = selectBestChant(entries, mode, highFeast, massNumbers);
+        return best ? entryToOrdinaryChant(best) : null;
+    };
+    const results = [];
+    const ky = pick("ky");
+    if (ky)
+        results.push(ky);
+    // Gloria is omitted in penitential seasons (Advent, Septuagesima, Lent).
+    // Maundy Thursday keeps it — its Gloria is a deliberate breach of Lenten
+    // austerity, sung with the bells before they fall silent.
+    const glOmitted = PENITENTIAL_SEASONS.has(feast.season) && !isMaundyThursday;
+    if (!glOmitted) {
+        const gl = pick("gl");
+        if (gl)
+            results.push(gl);
+    }
+    // Credo — In Cena Domini's Mass has no Creed.
+    if (!isMaundyThursday) {
+        const allowed = allowedCredos(masses);
+        const credoCode = selectCredoCode(feast, allowed);
+        if (credoCode) {
+            const credoEntries = KYRIALE.filter((e) => e.office === "cr");
+            const named = credoEntries.find((e) => e.incipit.includes(credoCode));
+            const best = named ?? selectBestChant(credoEntries, mode, highFeast, massNumbers);
+            if (best) {
+                const cr = entryToOrdinaryChant(best);
+                cr.ordinarium = `Credo ${credoCode}`;
+                results.push(cr);
+            }
+        }
+    }
+    const sa = pick("sa");
+    if (sa)
+        results.push(sa);
+    const ag = pick("ag");
+    if (ag)
+        results.push(ag);
+    if (glOmitted) {
+        const be = pick("be");
+        if (be)
+            results.push(be);
+    }
+    else {
+        const it = pick("it");
+        if (it)
+            results.push(it);
+    }
+    // Sprinkle rite: Vidi aquam in Paschaltide (through the Pentecost octave),
+    // Asperges otherwise. It precedes the principal Sunday Mass only — not the
+    // evening Mass of In Cena Domini.
+    if (!isMaundyThursday) {
+        const sprinkleType = feast.season === "pasc" ? "va" : "as";
+        const sprinkleEntries = entriesForOffice(sprinkleType, massNumbers);
+        const sprinkleBest = selectBestChant(sprinkleEntries, mode, highFeast, massNumbers);
+        if (sprinkleBest)
+            results.push(entryToOrdinaryChant(sprinkleBest));
+    }
+    return results;
+}
+function toArray(v) {
+    if (v === undefined)
+        return undefined;
+    return Array.isArray(v) ? v : [v];
+}
+/**
+ * Mass ordinary retrieval (`tonus.ordinarium`) from the Kyriale. A feast
+ * drives mass selection; `mass` pins a kyriale number directly.
+ */
+export function getOrdinary(query) {
+    if (!query || Object.keys(query).length === 0)
+        return [];
+    const feasts = toArray(query.feast);
+    const filterMode = query.mode != null ? Number(query.mode) : undefined;
+    let results;
+    if (feasts) {
+        results = feasts.flatMap((f) => ordinaryForFeast(f, query.mass, filterMode));
+    }
+    else if (query.mass != null || query.ordinary) {
+        // Direct kyriale query without feast context
+        let entries = KYRIALE.slice();
+        if (query.mass != null)
+            entries = entries.filter((e) => e.mass === query.mass);
+        if (query.ordinary)
+            entries = entries.filter((e) => e.office === query.ordinary);
+        if (filterMode != null)
+            entries = entries.filter((e) => e.mode === String(filterMode));
+        const offset = Math.max(0, query.offset ?? 0);
+        const limit = query.limit == null ? entries.length : Math.max(0, query.limit);
+        results = entries.slice(offset, offset + limit).map(entryToOrdinaryChant);
+    }
+    else {
+        return [];
+    }
+    // Apply remaining CantusQuery filters
+    if (query.incipit) {
+        const needle = query.incipit.toLowerCase();
+        results = results.filter((c) => c.incipit.toLowerCase().includes(needle));
+    }
+    if (query.id) {
+        const ids = new Set(toArray(query.id));
+        results = results.filter((c) => ids.has(c.id));
+    }
+    if (query.source) {
+        const sources = new Set(toArray(query.source));
+        results = results.filter((c) => c.source.code != null && sources.has(c.source.code));
+    }
+    return results;
+}
+//# sourceMappingURL=ordinary.js.map

package/dist/engines/chant/propers.d.ts

@@ -0,0 +1,8 @@
+import type { Chant, PropriumQuery } from "./types.js";
+/**
+ * Mass proper retrieval (`tonus.proprium`): Introitus, Graduale,
+ * Alleluia/Tractus, Offertorium, Communio. A feast narrows the result;
+ * feasts without a dedicated proper fall back to the Commune Sanctorum.
+ */
+export declare function getPropers(query?: PropriumQuery): Chant[];
+//# sourceMappingURL=propers.d.ts.map

package/dist/engines/chant/propers.js

@@ -0,0 +1,107 @@
+// ---------------------------------------------------------------------------
+// engines/chant/propers — Mass proper lookup
+// ---------------------------------------------------------------------------
+import { resolveChant } from "./chant.js";
+import { temporaSundayId } from "../cal/date.js";
+import { PROPERS } from "../../data/propers.js";
+import { COMMUNE_PROPERS, FEAST_COMMUNE } from "../../data/commune.js";
+let _byFeastId = null;
+function byFeastId() {
+    if (!_byFeastId)
+        _byFeastId = new Map(PROPERS.map((p) => [p.feastId, p]));
+    return _byFeastId;
+}
+let _communeByFeast = null;
+function communeByFeast() {
+    if (!_communeByFeast)
+        _communeByFeast = new Map(FEAST_COMMUNE.map((f) => [f.feastId, f.commune]));
+    return _communeByFeast;
+}
+let _communePropers = null;
+function communePropers() {
+    if (!_communePropers)
+        _communePropers = new Map(COMMUNE_PROPERS.map((c) => [c.commune, c]));
+    return _communePropers;
+}
+const PROPER_SLOTS = ["in", "gr", "al", "tr", "of", "co"];
+function resolveProperChants(feastId) {
+    const map = byFeastId();
+    const proper = map.get(feastId) ?? null;
+    const sunday = temporaSundayId(feastId);
+    const seasonProper = sunday ? (map.get(sunday) ?? null) : null;
+    const commune = communeByFeast().get(feastId);
+    const communeProper = commune ? (communePropers().get(commune) ?? null) : null;
+    const results = [];
+    for (const slot of PROPER_SLOTS) {
+        const id = proper?.[slot] ?? seasonProper?.[slot] ?? communeProper?.[slot] ?? null;
+        const chant = resolveChant(id);
+        if (chant)
+            results.push(chant);
+    }
+    return results;
+}
+function toFeastArray(v) {
+    if (v === undefined)
+        return undefined;
+    return Array.isArray(v) ? v : [v];
+}
+function toArray(v) {
+    if (v === undefined)
+        return undefined;
+    return Array.isArray(v) ? v : [v];
+}
+/**
+ * Mass proper retrieval (`tonus.proprium`): Introitus, Graduale,
+ * Alleluia/Tractus, Offertorium, Communio. A feast narrows the result;
+ * feasts without a dedicated proper fall back to the Commune Sanctorum.
+ */
+export function getPropers(query) {
+    if (!query || Object.keys(query).length === 0)
+        return [];
+    const feasts = toFeastArray(query.feast);
+    let results;
+    if (feasts) {
+        results = feasts.flatMap((f) => resolveProperChants(f.id));
+    }
+    else {
+        // No feast filter — resolve all propers
+        results = PROPERS.flatMap((p) => resolveProperChants(p.feastId));
+    }
+    const offices = toArray(query.office);
+    if (offices) {
+        const set = new Set(offices);
+        results = results.filter((c) => set.has(c.office));
+    }
+    const modes = toArray(query.mode);
+    if (modes) {
+        const set = new Set(modes.map(String));
+        results = results.filter((c) => c.mode != null && set.has(c.mode));
+    }
+    const sources = toArray(query.source);
+    if (sources) {
+        const set = new Set(sources);
+        results = results.filter((c) => c.source.code != null && set.has(c.source.code));
+    }
+    if (query.incipit) {
+        const needle = query.incipit.toLowerCase();
+        results = results.filter((c) => c.incipit.toLowerCase().includes(needle));
+    }
+    if (query.id) {
+        const ids = toArray(query.id);
+        const set = new Set(ids);
+        results = results.filter((c) => set.has(c.id));
+    }
+    const sort = query.sort ?? "incipit";
+    results.sort((a, b) => {
+        if (sort === "id")
+            return a.id.localeCompare(b.id);
+        if (sort === "mode")
+            return (String(a.mode ?? "").localeCompare(String(b.mode ?? "")) ||
+                a.incipit.localeCompare(b.incipit));
+        return a.incipit.localeCompare(b.incipit);
+    });
+    const offset = Math.max(0, query.offset ?? 0);
+    const limit = query.limit == null ? results.length : Math.max(0, query.limit);
+    return results.slice(offset, offset + limit);
+}
+//# sourceMappingURL=propers.js.map

package/dist/engines/chant/psalm.d.ts

@@ -0,0 +1,7 @@
+import { type Chant, type PsalmusQuery } from "./types.js";
+/**
+ * Psalm and canticle retrieval (`tonus.psalmus`) from the Psalterium,
+ * intoned to the psalm tones (modes 1-8 plus tonus peregrinus) as GABC.
+ */
+export declare function getPsalm(query?: PsalmusQuery): Chant[];
+//# sourceMappingURL=psalm.d.ts.map

package/dist/engines/chant/psalm.js

@@ -0,0 +1,60 @@
+// ---------------------------------------------------------------------------
+// engines/chant/psalm — psalm and canticle retrieval as intoned Chant[]
+// ---------------------------------------------------------------------------
+import { PSALMS } from "../../data/psalms.js";
+import { intone } from "./intone.js";
+import { MODE_LABELS } from "./types.js";
+const CANTICLE_NAMES = {
+    benedictus: 231,
+    magnificat: 234,
+    "nunc dimittis": 227,
+    "te deum": 240,
+    benedicite: 210,
+};
+function lookupVerses(psalm, verse) {
+    if (typeof psalm === "string") {
+        const named = CANTICLE_NAMES[psalm.toLowerCase()];
+        if (named)
+            return lookupVerses(named, verse);
+        const n = parseInt(psalm);
+        if (!isNaN(n))
+            return lookupVerses(n, verse);
+        return [];
+    }
+    let results = PSALMS.filter((v) => v.psalm === psalm);
+    if (verse)
+        results = results.filter((v) => v.verse === verse);
+    return results;
+}
+function verseToChant(v, mode, differentia, intonation) {
+    const gabc = intone(v, { mode, differentia, intonation });
+    return {
+        id: `psalm:${v.psalm}:${v.verse}`,
+        incipit: v.half1.slice(0, 40),
+        gabc,
+        office: "ps",
+        genus: "Psalmus",
+        mode: String(mode),
+        modus: mode === 0 ? "Tonus Peregrinus" : (MODE_LABELS[String(mode)] ?? `Modus ${mode}`),
+        pages: [],
+        source: {
+            book: "Psalterium",
+            year: new Date().getUTCFullYear(),
+            editor: "tonus",
+        },
+    };
+}
+/**
+ * Psalm and canticle retrieval (`tonus.psalmus`) from the Psalterium,
+ * intoned to the psalm tones (modes 1-8 plus tonus peregrinus) as GABC.
+ */
+export function getPsalm(query) {
+    if (!query || Object.keys(query).length === 0)
+        return [];
+    const verses = lookupVerses(query.psalm ?? 0, query.verse);
+    if (!verses.length)
+        return [];
+    const mode = query.mode ?? 8;
+    return verses.map((v) => verseToChant(v, mode, query.differentia, query.intonatio));
+}
+//# sourceMappingURL=psalm.js.map

package/dist/engines/chant/syllabify.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Split a single Latin word into syllables.
+ * e.g. "Dóminus" → ["Dó", "mi", "nus"]
+ *      "glória"  → ["gló", "ri", "a"]
+ *      "ánima"   → ["á", "ni", "ma"]
+ */
+export declare function syllabifyWord(word: string): string[];
+/**
+ * Syllabify a phrase (sequence of words).
+ * Returns syllables with " " tokens preserved between words.
+ * e.g. "Dixit Dóminus" → ["Di","xit"," ","Dó","mi","nus"]
+ */
+export declare function syllabifyPhrase(phrase: string): string[];
+export declare function hyphenateWord(word: string): string;
+export declare function selectVowel(text: string): {
+    vowel: string;
+    accent: boolean;
+};
+export declare function detectVowelAccent(text: string): boolean;
+//# sourceMappingURL=syllabify.d.ts.map

package/dist/engines/chant/syllabify.js

@@ -0,0 +1,192 @@
+// ---------------------------------------------------------------------------
+// engines/chant/syllabify — Latin syllabification (ecclesiastical rules)
+// ---------------------------------------------------------------------------
+//
+// Rules applied (in order):
+//   1. Digraphs ae, oe, au, ei, eu → single vowel unit (never split)
+//   2. qu → treated as single consonant (u is silent after q)
+//   3. V-ia/ie/io/iu/ua/ue/uo-V → always split before the i/u (ecclesiastical)
+//      Exception: ui after l/r is a diphthong (alleluia, huius)
+//   4. Single consonant between vowels → goes with following vowel (V·CV)
+//   5. Consonant clusters: muta cum liquida (tr, pr, br, gr, dr, cr, fr, pl, bl,
+//      cl, gl, fl) stay together; all other clusters split after first consonant
+//
+// Diacritics (áéíóúàèìòùâêîôû etc.) are treated as their base vowel throughout.
+// ── Character classes ──
+const VOWELS = new Set("aeiouyáéíóúàèìòùâêîôûäëïöüæœý");
+const SOFT_HYPHEN = "\u00ad";
+// Latin diphthongs: ae, oe, au, ei are single syllable.
+// eu is not a classical Latin diphthong (de-us, me-us split normally).
+const DIPHTHONGS = new Set(["ae", "oe", "au", "ei", "ui"]);
+// Muta cum liquida pairs that stay with the following vowel
+const MUTA_CUM_LIQUIDA = new Set([
+    "tr",
+    "dr",
+    "pr",
+    "br",
+    "cr",
+    "gr",
+    "fr",
+    "pl",
+    "bl",
+    "cl",
+    "gl",
+    "fl",
+    "th",
+    "ph",
+    "ch",
+]);
+// Strip diacritics for rule matching, keep original for output
+function baseChar(ch) {
+    return ch
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase();
+}
+function isVowelBase(ch) {
+    return VOWELS.has(baseChar(ch));
+}
+function isConsonantBase(ch) {
+    const b = baseChar(ch);
+    return /[a-z]/.test(b) && !VOWELS.has(b);
+}
+// ── Core syllabifier ──
+/**
+ * Split a single Latin word into syllables.
+ * e.g. "Dóminus" → ["Dó", "mi", "nus"]
+ *      "glória"  → ["gló", "ri", "a"]
+ *      "ánima"   → ["á", "ni", "ma"]
+ */
+export function syllabifyWord(word) {
+    if (word.length <= 2)
+        return [word];
+    const chars = Array.from(word);
+    const n = chars.length;
+    // Find all vowel positions (base-char aware).
+    const vpos = [];
+    for (let i = 0; i < n; i++) {
+        if (isVowelBase(chars[i])) {
+            const prev = i > 0 ? baseChar(chars[i - 1]) : "";
+            if (baseChar(chars[i]) === "u" && prev === "q")
+                continue;
+            vpos.push(i);
+        }
+    }
+    if (vpos.length <= 1)
+        return [word]; // monosyllable
+    // Build a set of positions where we insert a split (before this index)
+    const splits = new Set();
+    for (let vi = 0; vi < vpos.length - 1; vi++) {
+        const v1 = vpos[vi];
+        const v2 = vpos[vi + 1];
+        // Adjacent vowels (no consonants between them)
+        if (v2 === v1 + 1) {
+            const pair = baseChar(chars[v1]) + baseChar(chars[v2]);
+            if (DIPHTHONGS.has(pair))
+                continue;
+            // All other adjacent vowels split in ecclesiastical Latin
+            splits.add(v2);
+            continue;
+        }
+        // Consonants between v1 and v2
+        const consonants = chars.slice(v1 + 1, v2);
+        const cLen = consonants.length;
+        if (cLen === 0) {
+            // Shouldn't happen after digraph check, but guard
+            splits.add(v2);
+        }
+        else if (cLen === 1) {
+            // Single consonant → goes with following vowel: V | CV
+            splits.add(v1 + 1);
+        }
+        else {
+            // Cluster — check last two consonants for muta cum liquida
+            const last2 = consonants
+                .slice(-2)
+                .map((c) => baseChar(c))
+                .join("");
+            if (MUTA_CUM_LIQUIDA.has(last2)) {
+                // Keep muta+liquida together with following vowel: VC…·tCV
+                splits.add(v2 - 2);
+            }
+            else {
+                // Split after first consonant: VC·C…V
+                splits.add(v1 + 2);
+            }
+        }
+    }
+    // Build syllable strings from split positions
+    const splitArr = Array.from(splits).sort((a, b) => a - b);
+    const result = [];
+    let prev = 0;
+    for (const pos of splitArr) {
+        if (pos > prev)
+            result.push(chars.slice(prev, pos).join(""));
+        prev = pos;
+    }
+    result.push(chars.slice(prev).join(""));
+    return result.filter((s) => s.length > 0);
+}
+/**
+ * Syllabify a phrase (sequence of words).
+ * Returns syllables with " " tokens preserved between words.
+ * e.g. "Dixit Dóminus" → ["Di","xit"," ","Dó","mi","nus"]
+ */
+export function syllabifyPhrase(phrase) {
+    const tokens = phrase.split(/(\s+)/);
+    const result = [];
+    for (const token of tokens) {
+        if (!token.trim()) {
+            if (token)
+                result.push(" ");
+            continue;
+        }
+        // Strip leading/trailing punctuation, reattach after syllabification
+        const m = token.match(/^([^a-zA-ZÀ-ÿ]*)(.*?)([^a-zA-ZÀ-ÿ]*)$/u);
+        if (!m) {
+            result.push(token);
+            continue;
+        }
+        const [, lead, word, trail] = m;
+        if (!word) {
+            result.push(token);
+            continue;
+        }
+        const sylls = syllabifyWord(word);
+        if (lead)
+            sylls[0] = lead + sylls[0];
+        if (trail)
+            sylls[sylls.length - 1] += trail;
+        result.push(...sylls);
+    }
+    return result.filter((s, i) => !(s === " " && (i === 0 || i === result.length - 1)));
+}
+export function hyphenateWord(word) {
+    return syllabifyWord(word).join(SOFT_HYPHEN);
+}
+const ACCENTED = /[\u0301]/; // combining acute accent (NFD form)
+export function selectVowel(text) {
+    const expanded = text.replace(/ǽ/g, "áe").replace(/æ/g, "ae").replace(/œ/g, "oe");
+    const nfd = expanded.normalize("NFD");
+    let firstVowel = "";
+    let accentedVowel = "";
+    for (let i = 0; i < nfd.length; i++) {
+        const ch = nfd[i];
+        const base = ch.replace(/[\u0300-\u036f]/g, "").toLowerCase();
+        if (!isVowelBase(base))
+            continue;
+        const v = base === "y" ? "i" : base;
+        if (!firstVowel)
+            firstVowel = v;
+        if (!accentedVowel && i + 1 < nfd.length && ACCENTED.test(nfd[i + 1])) {
+            accentedVowel = v;
+        }
+    }
+    if (accentedVowel)
+        return { vowel: accentedVowel, accent: true };
+    return { vowel: firstVowel, accent: false };
+}
+export function detectVowelAccent(text) {
+    return selectVowel(text).accent;
+}
+//# sourceMappingURL=syllabify.js.map