@venite/components 0.16.7 → 0.16.13

package/dist/ldf/index-f441adec.js

@@ -1,2901 +0,0 @@
-import { c as createCommonjsModule, g as getDefaultExportFromCjs } from './_commonjsHelpers-8fe71198.js';
-
-function addOneDay(date) {
-    return new Date(date.getTime() + 60 * 60 * 24 * 1000);
-}
-function subtractOneDay(date) {
-    return new Date(date.getTime() - 60 * 60 * 24 * 1000);
-}
-
-// strip away everything but year, month, day
-function dateOnly(d) {
-    d.setHours(0);
-    d.setMinutes(0);
-    d.setSeconds(0);
-    d.setMilliseconds(0);
-    return d;
-}
-
-/** return date from year, month (1-12), and day
- * defaults to today if any of fields are undefined */
-function dateFromYMD(year, month, day) {
-    let d = new Date();
-    d = dateOnly(d);
-    if (year && month && day) {
-        d.setFullYear(parseInt(year));
-        d.setMonth(parseInt(month) - 1, parseInt(day));
-    }
-    return d;
-}
-/** Transforms a string like `YYYY-mm-dd` to a Date */
-function dateFromYMDString(ymd) {
-    const [y, m, d] = ymd.split('-');
-    return dateFromYMD(y, m, d);
-}
-/** Transform `Date` into YYYY-M-D */
-function dateToYMD(date) {
-    return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
-}
-
-/** Returns the date of Easter in a given year */
-function easterInYear(Y, julian = false) {
-    if (julian) {
-        // Computus — Meeus's Julian algorithm
-        const a = Y % 4, b = Y % 7, c = Y % 19, d = (19 * c + 15) % 30, e = (2 * a + 4 * b - d + 34) % 7, month = (d + e + 114) / 31, day = ((d + e + 114) % 31) + 1;
-        return dateOnly(new Date(Y, month - 1, day));
-    }
-    else {
-        // Computus - Meeus/Jones/Butcher algorithm
-        const a = Y % 19, b = Math.floor(Y / 100), c = Y % 100, d = Math.floor(b / 4), e = b % 4, f = Math.floor((b + 8) / 25), g = Math.floor((b - f + 1) / 3), h = (19 * a + b - d - g + 15) % 30, i = Math.floor(c / 4), k = c % 4, L = (32 + 2 * e + 2 * i - h - k) % 7, m = Math.floor((a + 11 * h + 22 * L) / 451), month = Math.floor((h + L - 7 * m + 114) / 31), day = ((h + L - 7 * m + 114) % 31) + 1;
-        return dateOnly(new Date(Y, month - 1, day));
-    }
-}
-
-function dailyOfficeYear(date, week) {
-    // The Daily Office Lectionary is arranged in a two-year cycle. Year One
-    // begins on the First Sunday of Advent preceding odd-numbered years, and
-    // Year Two begins on the First Sunday of Advent preceding even-numbered
-    // years.  (Thus, on the First Sunday of Advent, 1976, the Lectionary for
-    // Year One is begun.)
-    let D = [1, 2], year;
-    // if Advent or December, use this year
-    if (week.season === 'Advent' || date.getMonth() + 1 == 12) {
-        year = date.getFullYear();
-    }
-    else {
-        year = date.getFullYear() - 1;
-    }
-    return D[year % 2];
-}
-function rclYear(date, week) {
-    // The RCL is arranged in a three-year cycle. Year A
-    // begins on the First Sunday of Advent in 2016/19/22,
-    // Year B in 2017/20/23, Year C in 2018/21/24 etc.
-    const D = ['A', 'B', 'C'];
-    let year;
-    // if Advent or December, use this year
-    if (week.season === 'Advent' || date.getMonth() + 1 == 12) {
-        year = date.getFullYear();
-    }
-    else {
-        year = date.getFullYear() - 1;
-    }
-    return D[year % 3];
-}
-
-/**
- * LiturgicalDay represents a particular moment in the liturgical calendar,
- * like "Monday in Holy Week" or "The Eve of the Epiphany."
- */
-class LiturgicalDay {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        /** True if this moment is the evening. Used to indicate the eve of feasts. */
-        this.evening = false;
-        Object.assign(this, data);
-    }
-    /** Returns a native Date from the day's date string */
-    getDate() {
-        return dateFromYMDString(this.date);
-    }
-    /** Given a LiturgicalDay, returns a new LiturgicalDay that includes the feasts passed */
-    addHolyDays(holydays) {
-        var _a, _b, _c, _d;
-        const day = this;
-        holydays = holydays
-            // filter out eves if it's not evening
-            .filter((feast) => !feast.eve || this.evening)
-            // filter out days that are supposed to stop after a certain Sunday
-            // viz., the 1979 daily lectionary for January 8, 9, 10, 11, etc., stops at the 1st Sunday after the Epiphany
-            .filter((feast) => feast.stops_at_sunday !== day.week.slug)
-            .map((feast) => {
-            // if a feast has an `evening` field and it's evening, use that
-            if (feast.hasOwnProperty('evening') && this.evening == true) {
-                return feast.evening;
-            }
-            // if a feast has a `morning` field and it's morning, use that
-            else if (feast.hasOwnProperty('morning') && this.evening == false) {
-                return feast.morning;
-            }
-            // if a feast is the eve of something and it's evening, use that feast
-            else if (feast && feast.eve && this.evening == true) {
-                return feast;
-            }
-            // if none of these, just return the feast
-            else {
-                return feast;
-            }
-        })
-            .filter((feast) => !!feast);
-        // Determine whether a holy day takes precedence over the ordinary day
-        const observed = this.observedDay(this, (this.holy_days || new Array()).concat(holydays));
-        // overwrite the day's slug with the observed day's slug if they differ
-        const holy_day_rank = Number((_b = (_a = observed) === null || _a === void 0 ? void 0 : _a.type) === null || _b === void 0 ? void 0 : _b.rank), holy_day_is_observed = (observed === null || observed === void 0 ? void 0 : observed.slug) && ((observed === null || observed === void 0 ? void 0 : observed.slug) !== day.slug || holy_day_rank > 2), slug = holy_day_is_observed && holy_day_rank > 2 ? observed.slug : day.slug;
-        let propers = this.propers;
-        if (slug !== this.slug) {
-            propers = slug;
-        }
-        const color = observed.color || this.color, collect = observed.collect || this.collect, season = observed.season || this.season, octave = (_d = (_c = (this.holy_days || [])) === null || _c === void 0 ? void 0 : _c.concat(holydays)) === null || _d === void 0 ? void 0 : _d.map((holyday) => holyday.octave).filter((octave) => Boolean(octave)).reduce((acc, curr) => (acc ? acc : curr || acc), undefined);
-        return new LiturgicalDay(Object.assign(Object.assign({}, this), { slug, propers: holy_day_is_observed && holy_day_rank > 2 ? observed === null || observed === void 0 ? void 0 : observed.slug : propers, color,
-            season,
-            octave,
-            collect, holy_days: (this.holy_days || new Array()).concat(holydays), holy_day_observed: holy_day_is_observed ? observed : this.holy_day_observed }));
-    }
-    /** Given a `LiturgicalDay` and a set of `HolyDay`s, it returns whichever option takes precedence */
-    observedDay(day, holydays) {
-        // rank: Principal Feast (5), Sunday (4), Holy Day (3), random other days (2), ferial weekday (1)
-        function getRank(item, type) {
-            var _a;
-            // ranked items => go with rank
-            if (type == 'holyday') {
-                return ((_a = item === null || item === void 0 ? void 0 : item.type) === null || _a === void 0 ? void 0 : _a.rank) || 2;
-            }
-            else {
-                // if `day.date` is defined, used it to generate a date
-                // otherwise, use the current date
-                const date = day.date ? dateFromYMDString(day.date) : dateOnly(new Date());
-                // Sundays => 4
-                if (date.getDay() == 0) {
-                    return 4;
-                }
-                // weekdays => 1
-                else {
-                    return 1;
-                }
-            }
-        }
-        const sorted = holydays
-            .map((holyday) => ({ rank: getRank(holyday, 'holyday'), obj: holyday }))
-            .concat({ rank: getRank(day, 'weekday'), obj: day })
-            .sort((a, b) => {
-            // equal rank => choose earlier feast (probably )
-            if (a.rank === b.rank && a.obj.mmdd && b.obj.mmdd) {
-                const [bMM, bDD] = b.obj.mmdd.split('/'), [aMM, aDD] = a.obj.mmdd.split('/'), bDate = new Date(), aDate = new Date();
-                bDate.setMonth(parseInt(bMM) - 1);
-                bDate.setDate(parseInt(bDD));
-                aDate.setMonth(parseInt(aMM) - 1);
-                aDate.setDate(parseInt(aDD));
-                return a.obj.mmdd === b.obj.mmdd && a.obj.kalendar !== b.obj.kalendar
-                    ? a.obj.kalendar === day.kalendar
-                        ? -1
-                        : 1
-                    : aDate.getTime() - bDate.getTime();
-            }
-            else {
-                return b.rank - a.rank;
-            }
-        });
-        return Object.assign({}, sorted[0].obj);
-    }
-    // whether this day is ranked as a Major Feast
-    isFeast() {
-        var _a, _b, _c, _d;
-        const isSunday = this.getDate().getDay() === 0, hasRank = (((_b = (_a = this.holy_day_observed) === null || _a === void 0 ? void 0 : _a.type) === null || _b === void 0 ? void 0 : _b.rank) || 1) >= 3, holyWeek = (_c = this.slug) === null || _c === void 0 ? void 0 : _c.includes('holy-week'), easterWeek = ((_d = this.week) === null || _d === void 0 ? void 0 : _d.slug) === 'easter';
-        return isSunday || (hasRank && !holyWeek && !easterWeek);
-    }
-}
-
-//import { PROPERS } from './propers';
-const WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-/** Returns the `LiturgicalDay` that a given `Date` falls on */
-function liturgicalDay(date, kalendar, evening = false, week) {
-    const slug = buildDaySlug(date, week.slug), officeYear = dailyOfficeYear(date, week);
-    return new LiturgicalDay({
-        date: `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`,
-        kalendar,
-        evening,
-        slug,
-        propers: week.proper ? buildDaySlug(date, `proper-${week.proper}`) : slug,
-        week,
-        years: {
-            bcp1979_daily_office: officeYear,
-            bcp1979_daily_psalms: officeYear,
-            rclsunday: rclYear(date, week),
-        },
-        holy_days: [],
-        season: week.season,
-        color: week.color,
-    });
-}
-function buildDaySlug(date, slug) {
-    return `${WEEKDAYS[date.getDay()].toLowerCase()}-${slug}`;
-}
-
-/** Return `Date` of the Sunday before the given `Date`, stripped of time info */
-function sundayBefore(date) {
-    const s = date;
-    s.setDate(date.getDate() - date.getDay());
-    s.setHours(0);
-    s.setMinutes(0);
-    s.setSeconds(0);
-    s.setMilliseconds(0);
-    return s;
-}
-
-const PROPERS = [
-    '5/11',
-    '5/18',
-    '5/25',
-    '6/1',
-    '6/8',
-    '6/15',
-    '6/22',
-    '6/29',
-    '7/6',
-    '7/13',
-    '7/20',
-    '7/27',
-    '8/3',
-    '8/10',
-    '8/17',
-    '8/24',
-    '8/31',
-    '9/7',
-    '9/14',
-    '9/21',
-    '9/28',
-    '10/5',
-    '10/12',
-    '10/19',
-    '10/26',
-    '11/2',
-    '11/9',
-    '11/16',
-    '11/23',
-    '11/30',
-];
-
-/** Describes properties of the liturgical calendar used in a particular tradition. */
-class Calendar {
-}
-const TEC_1979_CALENDAR = {
-    julian: false,
-    easterCycleBegins: 7,
-    christmasCycleBegins: 4,
-    hasPropers: true,
-};
-
-// one week in milliseconds
-const ONE_WEEK = 7 * 24 * 60 * 60 * 1000;
-/** Returns the cycle and week offset that a given `Date` falls in */
-function liturgicalWeek(d, calendar = TEC_1979_CALENDAR) {
-    const date = new Date(d.getTime()); // avoid overwriting existing Date passed in
-    const year = date.getFullYear(), easter = easterInYear(year, calendar.julian), christmasEve = new Date(year, 11, 24), last_epiphany = sundayBefore(new Date(easter.getTime() - (calendar.easterCycleBegins - 0.1) * ONE_WEEK)), fourth_advent = sundayBefore(christmasEve), last_pentecost = sundayBefore(new Date(fourth_advent.getTime() - (calendar.christmasCycleBegins - 0.1) * ONE_WEEK));
-    if (date >= last_pentecost || date < last_epiphany) {
-        return christmasCycleWeek(date, calendar);
-    }
-    else {
-        return easterCycleWeek(date, calendar);
-    }
-}
-// Easter Cycle
-function easterCycleWeek(date, calendar = TEC_1979_CALENDAR) {
-    // weeks from Easter
-    const week = Math.round(weeksFromEaster(sundayBefore(date)) + calendar.easterCycleBegins);
-    return {
-        cycle: 'Easter',
-        week,
-        // TODO -- adjust based on calendar.easterCycleBegins
-        proper: week >= 14 && calendar.hasPropers ? calculateProper(date) : undefined,
-    };
-}
-function weeksFromEaster(date) {
-    return (date.getTime() - easterInYear(date.getFullYear()).getTime()) / ONE_WEEK;
-}
-function calculateProper(date) {
-    // TODO -- adjust based on calendar.easterCycleBegins
-    const lastSunday = sundayBefore(date);
-    let proper;
-    for (let ii = 0; ii < PROPERS.length - 1; ii++) {
-        if (closerThan(lastSunday, PROPERS[ii], PROPERS[ii + 1])) {
-            proper = ii + 1;
-            break;
-        }
-    }
-    return proper;
-}
-function closerThan(date, mmdd1, mmdd2) {
-    // mmdd1 and mmdd2 are format "May 11" : string
-    let [mm1, dd1] = mmdd1.split('/'), [mm2, dd2] = mmdd2.split('/'), d1 = dateFromYMD(date.getFullYear().toString(), mm1, dd1), d2 = dateFromYMD(date.getFullYear().toString(), mm2, dd2);
-    // is mmdd1 closer than mmdd2 to date?
-    return Math.abs(date.getTime() - d1.getTime()) < Math.abs(date.getTime() - d2.getTime());
-}
-// Christmas Cycle
-function christmasCycleWeek(d, calendar) {
-    const date = dateOnly(d);
-    const xmasYear = date.getMonth() >= 10 ? date.getFullYear() : date.getFullYear() - 1, xmas = new Date(xmasYear, 11, 25), xmasEve = new Date(xmasYear, 11, 24), epiphany = new Date(xmasYear + 1, 0, 6);
-    // If in Advent...
-    if (date <= xmasEve) {
-        // Have to calculate from Christmas Eve in case Christmas is a Sunday
-        const fourthAdv = sundayBefore(xmasEve), weeksFromFourthAdv = (sundayBefore(date).getTime() - fourthAdv.getTime()) / ONE_WEEK, week = Math.round(weeksFromFourthAdv) + 4;
-        return {
-            cycle: 'Advent',
-            week,
-            proper: week == 0 && calendar.hasPropers ? calculateProper(d) : undefined,
-        };
-    }
-    else if (date > xmasEve && date < epiphany) {
-        // Christmas, between Christmas and Epiphany
-        const weeksFromXmas = (date.getTime() - sundayBefore(xmas).getTime()) / ONE_WEEK;
-        return {
-            cycle: 'Christmas',
-            week: Math.floor(weeksFromXmas),
-        };
-    }
-    else {
-        // Epiphany
-        const weeksFromEpiphany = (date.getTime() - sundayBefore(epiphany).getTime()) / ONE_WEEK;
-        return {
-            cycle: 'Epiphany',
-            week: Math.floor(weeksFromEpiphany),
-        };
-    }
-}
-
-var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-function transferredFeast(liturgicalDayFinder, specialDayFinder, feastDayFinder, todayDate, acc = [], openDays = [], originalDay = undefined) {
-    var _a, _b, _c, _d, _e, _f;
-    return __awaiter(this, void 0, void 0, function* () {
-        // today
-        const today = yield liturgicalDayFinder(todayDate), todayIsSunday = (_a = today === null || today === void 0 ? void 0 : today.slug) === null || _a === void 0 ? void 0 : _a.startsWith('sunday-'), todaySpecial = yield specialDayFinder(today.slug), todayFeast = yield feastDayFinder(dateFromYMDString(today.date)), todayIsEmpty = isEmpty(acc[0], todayIsSunday, todaySpecial, todayFeast);
-        // yesterday
-        const yesterdayDate = subtractOneDay(todayDate), yesterday = yield liturgicalDayFinder(yesterdayDate), yesterdayIsSunday = (_b = yesterday === null || yesterday === void 0 ? void 0 : yesterday.slug) === null || _b === void 0 ? void 0 : _b.startsWith('sunday-'), yesterdaySpecial = yield specialDayFinder(yesterday.slug), yesterdayFeast = yield feastDayFinder(dateFromYMDString(yesterday.date)), yesterdayIsEmpty = isEmpty(acc[0], yesterdayIsSunday, yesterdaySpecial, yesterdayFeast);
-        const dayBeforeYesterdayDate = subtractOneDay(yesterdayDate), dayBeforeYesterday = yield liturgicalDayFinder(dayBeforeYesterdayDate), dayBeforeYesterdayIsSunday = (_c = dayBeforeYesterday === null || dayBeforeYesterday === void 0 ? void 0 : dayBeforeYesterday.slug) === null || _c === void 0 ? void 0 : _c.startsWith('sunday-'), dayBeforeYesterdaySpecial = yield specialDayFinder(dayBeforeYesterday === null || dayBeforeYesterday === void 0 ? void 0 : dayBeforeYesterday.slug), dayBeforeYesterdayFeast = yield feastDayFinder(dateFromYMDString(dayBeforeYesterday === null || dayBeforeYesterday === void 0 ? void 0 : dayBeforeYesterday.date)), dayBeforeYesterdayIsEmpty = isEmpty(acc[0], dayBeforeYesterdayIsSunday, dayBeforeYesterdaySpecial, dayBeforeYesterdayFeast);
-        //console.log('\n\ntoday is ', today.date);
-        //console.log('acc is', acc.map(hd => hd.slug));
-        //console.log('openDays is ', openDays.map((day) => day.slug));
-        // if both days are empty
-        if (todayIsEmpty && yesterdayIsEmpty) {
-            //console.log('today is empty and yesterday is empty');
-            // in Christmastide, we need to check an extra day, for the cases in which Christmas is Sunday and feasts can be transferred several days
-            const isChristmastide = todayDate.getMonth() === 11 && todayDate.getDate() > 25;
-            // check ONE more day -- we will rarely need to transfer more than two days, but it does happen around Easter Week sometimes
-            if (dayBeforeYesterdayIsEmpty) {
-                //console.log('  and the day before yesterday is empty');
-                const openDaySlugs = openDays.map((day) => day.slug), originalDayIndex = openDaySlugs
-                    .reverse() // because accumulate moving backwards
-                    .indexOf((originalDay === null || originalDay === void 0 ? void 0 : originalDay.slug) || '') || 0;
-                //console.log('yielding a transferred feast, which is the ', originalDayIndex < 0 ? 0 : originalDayIndex, originalDay?.slug, 'th item in ', acc.map(hd => hd.slug));
-                return acc.reverse()[originalDayIndex < 0 ? 0 : originalDayIndex]; // reverse because accumulate moving backwards
-            }
-            else {
-                //console.log('  and the day before yesterday is not empty');
-                return transferredFeast(liturgicalDayFinder, specialDayFinder, feastDayFinder, // pass helpers
-                subtractOneDay(todayDate), // recurse back to yesterday
-                acc, [...openDays, today], originalDay || today);
-            }
-        }
-        // if today is empty and yesterday is not empty, recurse back one more day
-        else if (todayIsEmpty && !yesterdayIsEmpty) {
-            //console.log('today is empty and yesterday is not empty');
-            const observed = todayFeast ? today.observedDay(today, [todayFeast, yesterdayFeast || todayFeast]) : today, isObserved = observed.slug === (todayFeast === null || todayFeast === void 0 ? void 0 : todayFeast.slug);
-            //console.log('is today’s feast observed today?', isObserved);
-            return transferredFeast(liturgicalDayFinder, specialDayFinder, feastDayFinder, // pass helpers
-            subtractOneDay(todayDate), // check yesterday
-            todayFeast && !todayFeast.eve && !isObserved && Number((_d = todayFeast === null || todayFeast === void 0 ? void 0 : todayFeast.type) === null || _d === void 0 ? void 0 : _d.rank) >= 3 ? [...acc, todayFeast] : acc, // include today's feast, but don't transfer "Eve of...",
-            [...openDays, today], originalDay || today);
-        }
-        // if today is not empty and today's feast is not observed...
-        else {
-            //console.log('today is not empty');
-            if (yesterdayIsEmpty) {
-                //console.log('  yesterday is empty');
-                // if today is observed today don't transfer
-                const observed = todayFeast ? today.observedDay(today, [todayFeast]) : today;
-                if (observed.slug == (todayFeast === null || todayFeast === void 0 ? void 0 : todayFeast.slug)) {
-                    //console.log('    and the feast is observed today');
-                    return transferredFeast(liturgicalDayFinder, specialDayFinder, feastDayFinder, // pass helpers
-                    subtractOneDay(todayDate), // check yesterday
-                    acc, openDays, originalDay || today);
-                }
-                else {
-                    //console.log('    and the feast is not observed today');
-                    return transferredFeast(liturgicalDayFinder, specialDayFinder, feastDayFinder, // pass helpers
-                    subtractOneDay(todayDate), // check yesterday
-                    todayFeast && !todayFeast.eve && Number((_e = todayFeast === null || todayFeast === void 0 ? void 0 : todayFeast.type) === null || _e === void 0 ? void 0 : _e.rank) >= 3 ? [...acc, todayFeast] : acc, openDays, originalDay || today);
-                }
-            }
-            else {
-                //console.log('  yesterday is not empty');
-                const observed = todayFeast ? today.observedDay(today, [todayFeast]) : today, isObserved = observed.slug === (todayFeast === null || todayFeast === void 0 ? void 0 : todayFeast.slug);
-                //console.log('     is today’s feast observed?', isObserved);
-                return transferredFeast(liturgicalDayFinder, specialDayFinder, feastDayFinder, // pass helpers
-                subtractOneDay(todayDate), // check yesterday
-                todayFeast && !todayFeast.eve && !isObserved && Number((_f = todayFeast === null || todayFeast === void 0 ? void 0 : todayFeast.type) === null || _f === void 0 ? void 0 : _f.rank) >= 3
-                    ? [...acc, todayFeast]
-                    : acc, // include today's feast, but don't transfer "Eve of..."
-                openDays, originalDay || today);
-            }
-        }
-    });
-}
-function isEmpty(forFeast, isSunday, special, feast) {
-    const isEmptyCheckList = [special, feast]
-        .concat(isSunday ? { type: { rank: 4 } } : undefined) // if it's a Sunday, it's a 4 by default
-        .map((day) => { var _a; return (_a = day === null || day === void 0 ? void 0 : day.type) === null || _a === void 0 ? void 0 : _a.rank; })
-        .filter((rank) => { var _a, _b; return rank && rank > ((_b = (_a = forFeast === null || forFeast === void 0 ? void 0 : forFeast.type) === null || _a === void 0 ? void 0 : _a.rank) !== null && _b !== void 0 ? _b : 3); });
-    return isEmptyCheckList.length == 0;
-}
-
-class Condition {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        Object.assign(this, data);
-    }
-    /** Given a liturgical day and a set of preferences, evaluates whether the condition should be included */
-    include(day, prefs = {}) {
-        var _a;
-        let include = true, evaluatedConditions = new Array(include);
-        // approach: for every possible condition included, push its truth
-        // onto evaluatedConditions — then reduce the array and require each condition given to be true
-        // `day`, `season`, and `weekday` each operate on an except/only pattern
-        // `day`: is day.slug in the `only` list (and not in the `except` list)?
-        this.exceptOnlyFactory('day', day.slug, evaluatedConditions);
-        // `week`: is day.week.slug in the `only` list (and not in the `except` list)?
-        this.exceptOnlyFactory('week', (_a = day.week) === null || _a === void 0 ? void 0 : _a.slug, evaluatedConditions);
-        // `weekday`:
-        this.exceptOnlyFactory('weekday', ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][dateFromYMDString(day.date).getDay()], evaluatedConditions);
-        // `season`: is day.week.season (the 'base season' for e.g., a saints' day in Lent)
-        // or day.season (the actual season being observed) in the `only` list (and not in `except`)?
-        if (this.hasOwnProperty('season') && this.season !== undefined) {
-            if (this.season.except !== undefined && this.season.except.length > 0) {
-                evaluatedConditions.push(!this.season.except.includes(day.season));
-                evaluatedConditions.push(!this.season.except.includes(day.week.season));
-            }
-            if (this.season.only !== undefined && this.season.only.length > 0) {
-                evaluatedConditions.push(this.season.only.includes(day.season) || this.season.only.includes(day.week.season));
-            }
-        }
-        // `feastDay`
-        if (this.hasOwnProperty('feastDay') && this.feastDay !== undefined) {
-            const highestFeastRank = Math.max(
-            // highest rank of holy days given
-            ...(day.holy_days || [])
-                .filter((a) => !!a) // exclude any null or undefined from array
-                .map((a) => (a && a.type && a.type.rank ? a.type.rank : 3))), isSunday = dateFromYMDString(day.date).getDay() == 0, isFeast = highestFeastRank >= 3 || isSunday;
-            evaluatedConditions.push(isFeast == this.feastDay);
-        }
-        // `date`
-        if (this.hasOwnProperty('date') && this.date !== undefined) {
-            const liturgyDate = dateFromYMDString(day.date);
-            for (const property in this.date) {
-                try {
-                    const [month, date] = (this.date[property] || '').split('/'), conditionDate = new Date(liturgyDate.getFullYear(), parseInt(month) - 1, parseInt(date));
-                    if (property == 'lt') {
-                        evaluatedConditions.push(liturgyDate.getTime() < conditionDate.getTime());
-                    }
-                    else if (property == 'lte') {
-                        evaluatedConditions.push(liturgyDate.getTime() <= conditionDate.getTime());
-                    }
-                    else if (property == 'gt') {
-                        evaluatedConditions.push(liturgyDate.getTime() > conditionDate.getTime());
-                    }
-                    else if (property == 'gte') {
-                        evaluatedConditions.push(liturgyDate.getTime() >= conditionDate.getTime());
-                    }
-                }
-                catch (e) {
-                    throw 'Date is formatted incorrectly (should be MM/DD).';
-                }
-            }
-        }
-        // `day_of_month`
-        if (this.hasOwnProperty('day_of_month') && this.day_of_month !== undefined) {
-            const liturgyDate = dateFromYMDString(day.date), liturgyDayOfMonth = liturgyDate.getDate();
-            for (const property in this.day_of_month) {
-                if (property == 'eq') {
-                    evaluatedConditions.push(liturgyDayOfMonth == Number(this.day_of_month.eq));
-                }
-                else if (property == 'neq') {
-                    evaluatedConditions.push(liturgyDayOfMonth != Number(this.day_of_month.neq));
-                }
-            }
-        }
-        // `preference`
-        if (this.hasOwnProperty('preference') && this.preference !== undefined) {
-            if (this.preference.is) {
-                evaluatedConditions.push(prefs[this.preference.key] == this.preference.value);
-            }
-            else {
-                evaluatedConditions.push(prefs[this.preference.key] !== this.preference.value);
-            }
-        }
-        return evaluatedConditions.reduce((a, b) => a && b, true);
-    }
-    exceptOnlyFactory(property, include, evaluatedConditions) {
-        const obj = this[property];
-        if (obj !== undefined) {
-            if (obj.except) {
-                evaluatedConditions.push(!obj.except.includes(include));
-            }
-            if (obj.only) {
-                evaluatedConditions.push(obj.only.includes(include));
-            }
-        }
-    }
-}
-
-var Responsive;
-(function (Responsive) {
-    Responsive["AllSizes"] = "all";
-    Responsive["SmallOnly"] = "small-only";
-    Responsive["SmallHidden"] = "small-hidden";
-})(Responsive || (Responsive = {}));
-const TYPES = [
-    'liturgy',
-    'heading',
-    'option',
-    'refrain',
-    'rubric',
-    'text',
-    'responsive',
-    'bible-reading',
-    'psalm',
-    'meditation',
-    'image',
-    'parallel',
-];
-const LOOKUP_TYPES = ['lectionary', 'canticle', 'category', 'slug', 'collect'];
-const DISPLAY_FORMATS = ['default', 'omit', 'unison', 'abbreviated'];
-/** Represents a liturgy of any scope and concreteness, from a complete bullletin to a single prayer. */
-class LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        Object.assign(this, data);
-    }
-    /** Evaluates the full set of conditions attached to the document and returns a boolean of whether it should be included
-     * given the day and assigned preferences  */
-    include(day, prefs = {}) {
-        if (this.condition !== undefined) {
-            const evaluatedConditions = (this.condition.conditions || []).map((condition) => {
-                if (!(condition instanceof Condition)) {
-                    condition = new Condition(condition);
-                }
-                return condition.include(day || this.day, prefs);
-            });
-            //console.log(evaluatedConditions);
-            if (this.condition.mode == 'or') {
-                return evaluatedConditions.reduce((a, b) => a || b, false);
-            }
-            else {
-                return evaluatedConditions.reduce((a, b) => a && b, true);
-            }
-        }
-        else {
-            return true;
-        }
-    }
-    /** Returns the list of all possible `type` values */
-    availableTypes() {
-        return TYPES;
-    }
-    /** Returns the list of all possible `style` values. Child classes should override if they have styles available. */
-    availableStyles() {
-        return [];
-    }
-    /** Returns the list of all possible `lookup.type` values */
-    availableLookupTypes() {
-        return LOOKUP_TYPES;
-    }
-    /** Returns the list of all available `display_format` values */
-    availableDisplayFormats() {
-        return DISPLAY_FORMATS;
-    }
-}
-
-const BIBLE_BOOK_ABBREVIATIONS = [
-    {
-        name: 'Genesis',
-        aliases: ['Gn', 'Gen', 'Genesis'],
-    },
-    {
-        name: 'Exodus',
-        aliases: ['Exod', 'Ex', 'Exo', 'Exodus'],
-    },
-    {
-        name: 'Leviticus',
-        aliases: ['Lev', 'Lv', 'Leviticus'],
-    },
-    {
-        name: 'Numbers',
-        aliases: ['Num', 'Numbers'],
-    },
-    {
-        name: 'Deuteronomy',
-        aliases: ['Deut', 'Deuteronomy'],
-    },
-    {
-        name: 'Joshua',
-        aliases: ['Josh', 'Joshua'],
-    },
-    {
-        name: 'Judges',
-        aliases: ['Judg', 'Jdg', 'Judges'],
-    },
-    {
-        name: 'Ruth',
-        aliases: ['Ruth'],
-    },
-    {
-        name: '1 Samuel',
-        aliases: ['1Sam', '1 Sam', '1st Sam', '1st Samuel', 'First Samuel', '1 Samuel'],
-    },
-    {
-        name: '2 Samuel',
-        aliases: ['2Sam', '2 Sam', '2nd Sam', '2nd Samuel', 'Second Samuel', '2 Samuel'],
-    },
-    {
-        name: '1 Kings',
-        aliases: ['1Kgs', '1 Kgs', '1st Kgs', '1st Kings', 'First Kings', '1 Kings'],
-    },
-    {
-        name: '2 Kings',
-        aliases: ['2Kgs', '2 Kgs', '2nd Kgs', '2nd Kings', 'Second Kings', '2 Kings'],
-    },
-    {
-        name: '1 Chronicles',
-        aliases: ['1Chr', '1 Chr', '1st Chr', '1st Chronicles', 'First Chronicles', '1 Chronicles'],
-    },
-    {
-        name: '2 Chronicles',
-        aliases: ['2Chr', '2 Chr', '2nd Chr', '2nd Chronicles', 'Second Chronicles', '2 Chronicles'],
-    },
-    {
-        name: 'Ezra',
-        aliases: ['Ezra'],
-    },
-    {
-        name: 'Nehemiah',
-        aliases: ['Neh', 'Nehemiah'],
-    },
-    {
-        name: 'Esther',
-        aliases: ['Esth', 'Est', 'Esther'],
-    },
-    {
-        name: 'Job',
-        aliases: ['Jb', 'Job'],
-    },
-    {
-        name: 'Psalms',
-        aliases: ['Ps', 'Psalm', 'Psalms'],
-    },
-    {
-        name: 'Proverbs',
-        aliases: ['Prov', 'Pro', 'Proverbs'],
-    },
-    {
-        name: 'Ecclesiastes',
-        aliases: ['Eccl', 'Ecc', 'Ecclesiastes'],
-    },
-    {
-        name: 'The Song of Solomon',
-        aliases: ['Song', 'Song of Songs', 'Song of Solomon', 'Cant'],
-    },
-    {
-        name: 'Isaiah',
-        aliases: ['Isa', 'Is', 'Isaiah'],
-    },
-    {
-        name: 'Jeremiah',
-        aliases: ['Jer', 'Jeremiah'],
-    },
-    {
-        name: 'Letter of Jeremiah',
-        aliases: ['EJer', 'EpJer', 'Epistle of Jeremiah'],
-    },
-    {
-        name: 'Lamentations',
-        aliases: ['Lam', 'Lamentations'],
-    },
-    {
-        name: 'Ezekiel',
-        aliases: ['Ezek', 'Ezekiel'],
-    },
-    {
-        name: 'Daniel',
-        aliases: ['Dan', 'Daniel'],
-    },
-    {
-        name: 'Hosea',
-        aliases: ['Hos', 'Hosea'],
-    },
-    {
-        name: 'Joel',
-        aliases: ['Joel'],
-    },
-    {
-        name: 'Amos',
-        aliases: ['Amos'],
-    },
-    {
-        name: 'Obadiah',
-        aliases: ['Obad', 'Oba', 'Obadiah'],
-    },
-    {
-        name: 'Jonah',
-        aliases: ['Jon', 'Jonah'],
-    },
-    {
-        name: 'Micah',
-        aliases: ['Mic', 'Micah'],
-    },
-    {
-        name: 'Nahum',
-        aliases: ['Nah', 'Nahum'],
-    },
-    {
-        name: 'Habakkuk',
-        aliases: ['Hab', 'Habakkuk'],
-    },
-    {
-        name: 'Zephaniah',
-        aliases: ['Zeph', 'Zephaniah'],
-    },
-    {
-        name: 'Haggai',
-        aliases: ['Hag', 'Haggai'],
-    },
-    {
-        name: 'Zechariah',
-        aliases: ['Zech', 'Zechariah'],
-    },
-    {
-        name: 'Malachi',
-        aliases: ['Mal', 'Malachi'],
-    },
-    {
-        name: 'Tobit',
-        aliases: ['Tob', 'Tobit'],
-    },
-    {
-        name: 'Judith',
-        aliases: ['Jdt', 'Judith'],
-    },
-    {
-        name: 'Baruch',
-        aliases: ['Bar', 'Baruch'],
-    },
-    {
-        name: '1 Maccabees',
-        aliases: ['1Macc', '1 Maccabees', 'First Maccabees', '1 Macc'],
-    },
-    {
-        name: '2 Maccabees',
-        aliases: ['2Macc', '2 Maccabees', 'Second Maccabees', '2 Macc'],
-    },
-    {
-        name: 'Wisdom',
-        aliases: ['Wis', 'Wisdom'],
-    },
-    {
-        name: 'Sirach',
-        aliases: ['Sir', 'Ecclus', 'Ben Sira', 'Ecclesiasticus'],
-    },
-    {
-        name: '1 Esdras',
-        aliases: ['1 Esdr', '1 Esdras', '1 Esd', '1Esdras', '1Esdr', '1Esd'],
-    },
-    {
-        name: '2 Esdras',
-        aliases: ['2 Esdr', '2 Esdras', '2 Esd', '2Esdras', '2Esdr', '2Esd'],
-    },
-    {
-        name: 'Bel',
-        aliases: ['Bel', 'Bel & the Dragon'],
-    },
-    {
-        name: 'Azariah',
-        aliases: ['Azariah', 'Song of the Three Young Men', 'Song of the Three Childr.', 'Song of the Three Children'],
-    },
-    {
-        name: 'Matthew',
-        aliases: ['Matt', 'Matthew', 'Mt'],
-    },
-    {
-        name: 'Mark',
-        aliases: ['Mark', 'Mk'],
-    },
-    {
-        name: 'Luke',
-        aliases: ['Luke', 'Lk'],
-    },
-    {
-        name: 'John',
-        aliases: ['Jn', 'John', 'Joh'],
-    },
-    {
-        name: 'Acts',
-        aliases: ['Acts'],
-    },
-    {
-        name: 'Romans',
-        aliases: ['Rom', 'Romans'],
-    },
-    {
-        name: '1 Corinthians',
-        aliases: ['1Cor', '1 Cor', '1st Cor', '1st Corinthians', 'First Corinthians', '1 Corinthians'],
-    },
-    {
-        name: '2 Corinthians',
-        aliases: ['2Cor', '2 Cor', '2nd Cor', '2nd Corinthians', 'Second Corinthians', '2 Corinthians'],
-    },
-    {
-        name: 'Galatians',
-        aliases: ['Gal', 'Galatians'],
-    },
-    {
-        name: 'Ephesians',
-        aliases: ['Eph', 'Ephesians'],
-    },
-    {
-        name: 'Philippians',
-        aliases: ['Phil', 'Philippians'],
-    },
-    {
-        name: 'Colossians',
-        aliases: ['Col', 'Colossians'],
-    },
-    {
-        name: '1 Thessalonians',
-        aliases: ['1Thess', '1 Thess', '1st Thess', '1st Thessalonians', 'First Thessalonians', '1 Thessalonians'],
-    },
-    {
-        name: '2 Thessalonians',
-        aliases: ['2Thess', '2 Thess', '2nd Thess', '2nd Thessalonians', 'Second Thessalonians', '2 Thessalonians'],
-    },
-    {
-        name: '1 Timothy',
-        aliases: ['1 Tim', '1Tim', '1st Tim', '1st Timothy', 'First Timothy', '1 Timothy'],
-    },
-    {
-        name: '2 Timothy',
-        aliases: ['2 Tim', '2Tim', '2nd Tim', '2nd Timothy', 'Second Timothy', '2 Timothy'],
-    },
-    {
-        name: 'Titus',
-        aliases: ['Titus'],
-    },
-    {
-        name: 'Philemon',
-        aliases: ['Phlm', 'Philemon'],
-    },
-    {
-        name: 'Hebrews',
-        aliases: ['Heb', 'Hebrews'],
-    },
-    {
-        name: 'James',
-        aliases: ['Jas', 'James'],
-    },
-    {
-        name: '1 Peter',
-        aliases: ['1Pet', '1 Pet', '1st Pet', '1st Peter', 'First Peter', '1 Peter'],
-    },
-    {
-        name: '2 Peter',
-        aliases: ['2Pet', '2 Pet', '2nd Pet', '2nd Peter', 'Second Peter', '2 Peter'],
-    },
-    {
-        name: '1 John',
-        aliases: ['1John', '1 John', '1st John', 'First John', '1 Joh'],
-    },
-    {
-        name: '2 John',
-        aliases: ['2John', '2 John', '2nd John', 'Second John', '2 Joh'],
-    },
-    {
-        name: '3 John',
-        aliases: ['3John', '3 John', '3rd John', 'Third John', '3 Joh'],
-    },
-    {
-        name: 'Jude',
-        aliases: ['Jude', 'Jd'],
-    },
-    {
-        name: 'Revelation',
-        aliases: ['Rev', 'Revelation', 'Revelations', 'Apocalypse', 'Apoc'],
-    },
-];
-
-const BIBLE_BOOK_NAMES = {
-    Genesis: {
-        en: {
-            short: 'Genesis',
-            long: 'The Book of Genesis',
-        },
-    },
-    Exodus: {
-        en: {
-            short: 'Exodus',
-            long: 'The Book of Exodus',
-        },
-    },
-    Leviticus: {
-        en: {
-            short: 'Leviticus',
-            long: 'The Book of Leviticus',
-        },
-    },
-    Numbers: {
-        en: {
-            short: 'Numbers',
-            long: 'The Book of Numbers',
-        },
-    },
-    Deuteronomy: {
-        en: {
-            short: 'Deuteronomy',
-            long: 'The Book of Deuteronomy',
-        },
-    },
-    Joshua: {
-        en: {
-            short: 'Joshua',
-            long: 'The Book of Joshua',
-        },
-    },
-    Judges: {
-        en: {
-            short: 'Judges',
-            long: 'The Book of Judges',
-        },
-    },
-    Ruth: {
-        en: {
-            short: 'Ruth',
-            long: 'The Book of Ruth',
-        },
-    },
-    '1 Samuel': {
-        en: {
-            short: '1 Samuel',
-            long: 'The First Book of Samuel',
-        },
-    },
-    '2 Samuel': {
-        en: {
-            short: '2 Samuel',
-            long: 'The Second Book of Samuel',
-        },
-    },
-    '1 Kings': {
-        en: {
-            short: '1 Kings',
-            long: 'The First Book of Kings',
-        },
-    },
-    '2 Kings': {
-        en: {
-            short: '2 Kings',
-            long: 'The Second Book of Kings',
-        },
-    },
-    '1 Chronicles': {
-        en: {
-            short: '1 Chronicles',
-            long: 'The First Book of Chronicles',
-        },
-    },
-    '2 Chronicles': {
-        en: {
-            short: '2 Chronicles',
-            long: 'The Second Book of Chronicles',
-        },
-    },
-    Ezra: {
-        en: {
-            short: 'Ezra',
-            long: 'The Book of Ezra',
-        },
-    },
-    Nehemiah: {
-        en: {
-            short: 'Nehemiah',
-            long: 'The Book of Nehemiah',
-        },
-    },
-    Esther: {
-        en: {
-            short: 'Esther',
-            long: 'The Book of Esther',
-        },
-    },
-    Job: {
-        en: {
-            short: 'Job',
-            long: 'The Book of Job',
-        },
-    },
-    Psalms: {
-        en: {
-            short: 'Psalms',
-            long: 'The Psalms',
-        },
-    },
-    Proverbs: {
-        en: {
-            short: 'Proverbs',
-            long: 'The Book of Proverbs',
-        },
-    },
-    Ecclesiastes: {
-        en: {
-            short: 'Ecclesiastes',
-            long: 'The Book of Ecclesiastes',
-        },
-    },
-    'The Song of Solomon': {
-        en: {
-            short: 'The Song of Solomon',
-            long: 'The Song of Solomon',
-        },
-    },
-    Isaiah: {
-        en: {
-            short: 'Isaiah',
-            long: 'The Book of the Prophet Isaiah',
-        },
-    },
-    Jeremiah: {
-        en: {
-            short: 'Jeremiah',
-            long: 'The Book of the Prophet Jeremiah',
-        },
-    },
-    Lamentations: {
-        en: {
-            short: 'Lamentations',
-            long: 'The Book of Lamentations',
-        },
-    },
-    Ezekiel: {
-        en: {
-            short: 'Ezekiel',
-            long: 'The Book of the Prophet Ezekiel',
-        },
-    },
-    Daniel: {
-        en: {
-            short: 'Daniel',
-            long: 'The Book of Daniel',
-        },
-        'en-CA': {
-            short: 'Daniel',
-            long: 'The Book of the Prophet Daniel',
-        },
-    },
-    Hosea: {
-        en: {
-            short: 'Hosea',
-            long: 'The Book of the Prophet Hosea',
-        },
-    },
-    Joel: {
-        en: {
-            short: 'Joel',
-            long: 'The Book of the Prophet Joel',
-        },
-    },
-    Amos: {
-        en: {
-            short: 'Amos',
-            long: 'The Book of the Prophet Amos',
-        },
-    },
-    Obadiah: {
-        en: {
-            short: 'Obadiah',
-            long: 'The Book of the Prophet Obadiah',
-        },
-    },
-    Jonah: {
-        en: {
-            short: 'Jonah',
-            long: 'The Book of the Prophet Jonah',
-        },
-    },
-    Micah: {
-        en: {
-            short: 'Micah',
-            long: 'The Book of the Prophet Micah',
-        },
-    },
-    Nahum: {
-        en: {
-            short: 'Nahum',
-            long: 'The Book of the Prophet Nahum',
-        },
-    },
-    Habakkuk: {
-        en: {
-            short: 'Habakkuk',
-            long: 'The Book of the Prophet Habakkuk',
-        },
-    },
-    Zephaniah: {
-        en: {
-            short: 'Zephaniah',
-            long: 'The Book of the Prophet Zephaniah',
-        },
-    },
-    Haggai: {
-        en: {
-            short: 'Haggai',
-            long: 'The Book of the Prophet Haggai',
-        },
-    },
-    Zechariah: {
-        en: {
-            short: 'Zechariah',
-            long: 'The Book of the Prophet Zechariah',
-        },
-    },
-    Malachi: {
-        en: {
-            short: 'Malachi',
-            long: 'The Book of the Prophet Malachi',
-        },
-    },
-    Tobit: {
-        en: {
-            short: 'Tobit',
-            long: 'The Book of Tobit',
-        },
-    },
-    Azariah: {
-        en: {
-            short: 'The Song of the Three Children',
-            long: 'The Song of the Three Children',
-        },
-    },
-    Judith: {
-        en: {
-            short: 'Judith',
-            long: 'The Book of Judith',
-        },
-    },
-    Baruch: {
-        en: {
-            short: 'Baruch',
-            long: 'The Book of Baruch',
-        },
-    },
-    '1 Maccabees': {
-        en: {
-            short: '1 Maccabees',
-            long: 'The First Book of Maccabees',
-        },
-    },
-    '2 Maccabees': {
-        en: {
-            short: '2 Maccabees',
-            long: 'The Second Book of Maccabees',
-        },
-    },
-    Wisdom: {
-        en: {
-            short: 'Wisdom',
-            long: 'The Wisdom of Solomon',
-        },
-    },
-    Sirach: {
-        en: {
-            short: 'Sirach',
-            long: 'The Wisdom of Ben Sira',
-        },
-        'en-CA': {
-            short: 'Sirach',
-            long: 'The Book of Ecclesiasticus',
-        },
-    },
-    Matthew: {
-        en: {
-            short: 'Matthew',
-            long: 'The Gospel According to Matthew',
-        },
-        'en-CA': {
-            short: 'Matthew',
-            long: 'The Gospel According to St. Matthew',
-        },
-    },
-    Mark: {
-        en: {
-            short: 'Mark',
-            long: 'The Gospel According to Mark',
-        },
-        'en-CA': {
-            short: 'Mark',
-            long: 'The Gospel According to St. Mark',
-        },
-    },
-    Luke: {
-        en: {
-            short: 'Luke',
-            long: 'The Gospel According to Luke',
-        },
-        'en-CA': {
-            short: 'Luke',
-            long: 'The Gospel According to St. Luke',
-        },
-    },
-    John: {
-        en: {
-            short: 'John',
-            long: 'The Gospel According to John',
-        },
-        'en-CA': {
-            short: 'John',
-            long: 'The Gospel According to St. John',
-        },
-    },
-    Acts: {
-        en: {
-            short: 'Acts',
-            long: 'The Acts of the Apostles',
-        },
-        'en-CA': {
-            short: 'Acts',
-            long: 'The Book of the Acts of the Apostles',
-        },
-    },
-    Romans: {
-        en: {
-            short: 'Romans',
-            long: 'The Letter to the Romans',
-        },
-        'en-CA': {
-            short: 'Romans',
-            long: 'The Epistle of St. Paul the Apostle to the Romans',
-        },
-    },
-    '1 Corinthians': {
-        en: {
-            short: '1 Corinthians',
-            long: 'The First Letter to the Corinthians',
-        },
-        'en-CA': {
-            short: '1 Corinthians',
-            long: 'The First Epistle of St. Paul the Apostle to the Corinthians',
-        },
-    },
-    '2 Corinthians': {
-        en: {
-            short: '2 Corinthians',
-            long: 'The Second Letter to the Corinthians',
-        },
-        'en-CA': {
-            short: '2 Corinthians',
-            long: 'The Second Epistle of St. Paul the Apostle to the Corinthians',
-        },
-    },
-    Galatians: {
-        en: {
-            short: 'Galatians',
-            long: 'The Letter to the Galatians',
-        },
-        'en-CA': {
-            short: 'Galatians',
-            long: 'The Epistle of St. Paul the Apostle to the Galatians',
-        },
-    },
-    Ephesians: {
-        en: {
-            short: 'Ephesians',
-            long: 'The Letter to the Ephesians',
-        },
-        'en-CA': {
-            short: 'Ephesians',
-            long: 'The Epistle of St. Paul the Apostle to the Ephesians',
-        },
-    },
-    Philippians: {
-        en: {
-            short: 'Philippians',
-            long: 'The Letter to the Philippians',
-        },
-        'en-CA': {
-            short: 'Philippians',
-            long: 'The Epistle of St. Paul the Apostle to the Philippians',
-        },
-    },
-    Colossians: {
-        en: {
-            short: 'Colossians',
-            long: 'The Letter to the Colossians',
-        },
-        'en-CA': {
-            short: 'Colossians',
-            long: 'The Epistle of St. Paul the Apostle to the Colossians',
-        },
-    },
-    '1 Thessalonians': {
-        en: {
-            short: '1 Thessalonians',
-            long: 'The First Letter to the Thessalonians',
-        },
-        'en-CA': {
-            short: '1 Thessalonians',
-            long: 'The First Epistle of St. Paul the Apostle to the Thessalonians',
-        },
-    },
-    '2 Thessalonians': {
-        en: {
-            short: '2 Thessalonians',
-            long: 'The Second Letter to the Thessalonians',
-        },
-        'en-CA': {
-            short: '2 Thessalonians',
-            long: 'The Second Epistle of St. Paul the Apostle to the Thessalonians',
-        },
-    },
-    '1 Timothy': {
-        en: {
-            short: '1 Timothy',
-            long: 'The First Letter to Timothy',
-        },
-        'en-CA': {
-            short: '1 Timothy',
-            long: 'The First Epistle of St. Paul the Apostle to Timothy',
-        },
-    },
-    '2 Timothy': {
-        en: {
-            short: '2 Timothy',
-            long: 'The Second Letter to Timothy',
-        },
-        'en-CA': {
-            short: '2 Timothy',
-            long: 'The Second Epistle of St. Paul the Apostle to Timothy',
-        },
-    },
-    Titus: {
-        en: {
-            short: 'Titus',
-            long: 'The Letter to Titus',
-        },
-        'en-CA': {
-            short: 'Titus',
-            long: 'The Epistle of St. Paul the Apostle to Titus',
-        },
-    },
-    Philemon: {
-        en: {
-            short: 'Philemon',
-            long: 'The Letter to Philemon',
-        },
-        'en-CA': {
-            short: 'Philemon',
-            long: 'The Epistle of St. Paul the Apostle to Philemon',
-        },
-    },
-    Hebrews: {
-        en: {
-            short: 'Hebrews',
-            long: 'The Book of Hebrews',
-        },
-        'en-CA': {
-            short: 'Hebrews',
-            long: 'The Epistle to the Hebrews',
-        },
-    },
-    James: {
-        en: {
-            short: 'James',
-            long: 'The Letter of James',
-        },
-        'en-CA': {
-            short: 'James',
-            long: 'The Epistle General of St. James',
-        },
-    },
-    '1 Peter': {
-        en: {
-            short: '1 Peter',
-            long: 'The First Letter of Peter',
-        },
-        'en-CA': {
-            short: '1 Peter',
-            long: 'The First Epistle General of St. Peter',
-        },
-    },
-    '2 Peter': {
-        en: {
-            short: '2 Peter',
-            long: 'The Second Letter of Peter',
-        },
-        'en-CA': {
-            short: '2 Peter',
-            long: 'The Second Epistle General of St. Peter',
-        },
-    },
-    '1 John': {
-        en: {
-            short: '1 John',
-            long: 'The First Letter of John',
-        },
-        'en-CA': {
-            short: '2 John',
-            long: 'The First Epistle General of St. John',
-        },
-    },
-    '2 John': {
-        en: {
-            short: '2 John',
-            long: 'The Second Letter of John',
-        },
-        'en-CA': {
-            short: '2 John',
-            long: 'The Second Epistle General of St. John',
-        },
-    },
-    '3 John': {
-        en: {
-            short: '3 John',
-            long: 'The Third Letter of John',
-        },
-        'en-CA': {
-            short: '3 John',
-            long: 'The Third Epistle General of St. John',
-        },
-    },
-    Jude: {
-        en: {
-            short: 'Jude',
-            long: 'The Letter of Jude',
-        },
-        'en-CA': {
-            short: 'Jude',
-            long: 'The Epistle General of St. Jude',
-        },
-    },
-    Revelation: {
-        en: {
-            short: 'Revelation',
-            long: 'The Book of Revelation',
-        },
-        'en-CA': {
-            short: 'Revelation',
-            long: 'The Revelation to St. John the Divine',
-        },
-    },
-    '1 Esdras': {
-        en: {
-            short: '1 Esdras',
-            long: 'The Second Book of Esdras',
-        },
-    },
-    '2 Esdras': {
-        en: {
-            short: '2 Esdras',
-            long: 'The Second Book of Esdras',
-        },
-    },
-    Bel: {
-        en: {
-            short: 'Bel',
-            long: 'Bel and the Dragon',
-        },
-    },
-    'Letter of Jeremiah': {
-        en: {
-            short: 'Letter of Jeremiah',
-            long: 'The Letter of Jeremiah',
-        },
-    },
-};
-
-function ordinalSuffix(i) {
-    var j = i % 10, k = i % 100;
-    if (j == 1 && k != 11) {
-        return i + 'st';
-    }
-    if (j == 2 && k != 12) {
-        return i + 'nd';
-    }
-    if (j == 3 && k != 13) {
-        return i + 'rd';
-    }
-    return i + 'th';
-}
-
-const STYLES$6 = ['long', 'short'];
-/** BibleReading represents liturgical instructions. */
-class BibleReading extends LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        super(data);
-    }
-    /** Replaces ${longName} or ${shortName} in LD passed as intro with appropriate value */
-    compileIntro() {
-        var _a, _b, _c, _d;
-        if (this.metadata && this.metadata.intro) {
-            const abbrev = (_a = this.abbrevFromCitation()) !== null && _a !== void 0 ? _a : this.citation, bookCode = this.bookCodeFromAbbrev(abbrev !== null && abbrev !== void 0 ? abbrev : ''), longName = abbrev ? this.longNameFromBookCode(bookCode !== null && bookCode !== void 0 ? bookCode : '', this.language || 'en') : '—', shortName = abbrev ? this.shortNameFromBookCode(bookCode !== null && bookCode !== void 0 ? bookCode : '', this.language || 'en') : '—', chapter = this.chapterFromCitation(), verse = this.verseFromCitation();
-            const newValue = new Array();
-            const process = (s) => s
-                .replace(/\$\{longName\}/g, (longName !== null && longName !== void 0 ? longName : abbrev).replace('The', 'the'))
-                .replace(/\$\{shortName\}/g, shortName !== null && shortName !== void 0 ? shortName : abbrev)
-                .replace(/\$\{chapter\}/g, `${ordinalSuffix(Number(chapter) || 1)}`)
-                .replace(/\$\{verse\}/g, `${ordinalSuffix(Number(verse) || 1)}`);
-            (_d = (_c = (_b = this.metadata) === null || _b === void 0 ? void 0 : _b.intro) === null || _c === void 0 ? void 0 : _c.value) === null || _d === void 0 ? void 0 : _d.forEach((introValue) => {
-                // Intro is presumably a Text or similar
-                if (typeof introValue == 'string') {
-                    newValue.push(process(introValue));
-                }
-                // Intro is presumably a ResponsivePrayer or similar
-                else if (introValue.hasOwnProperty('text')) {
-                    newValue.push(Object.assign(Object.assign({}, introValue), { text: process(introValue.text) }));
-                }
-                // if it's neither of those, do nothing at all to it
-                else {
-                    newValue.push(process(introValue));
-                }
-            });
-            this.metadata.compiled_intro = new LiturgicalDocument(Object.assign(Object.assign({}, this.metadata.intro), { value: newValue }));
-        }
-    }
-    /** Generates an abbreviated book name from citation
-     * @example
-     * // returns 'Genesis'
-     * this.citation = 'Gen. 3:4'
-     * this.abbrevFromCitation() */
-    abbrevFromCitation() {
-        let citation;
-        try {
-            const matches = (this.citation || '').match(/(\d*\s*[a-zA-Z]+)/);
-            citation = matches ? matches[0] : '';
-        }
-        catch (e) {
-            citation = this.citation;
-        }
-        return citation.replace(/\./g, '');
-    }
-    /** Gives number of first chapter of citation */
-    chapterFromCitation() {
-        var _a;
-        const matches = (_a = (this.citation || '').split(';')[0]) === null || _a === void 0 ? void 0 : _a.match(/[\s\.:](\d+)/g);
-        if (matches) {
-            const [chapter] = matches;
-            return typeof chapter === 'string' ? chapter.trim().replace(/[\.,:]/g, '') : undefined;
-        }
-        else {
-            return undefined;
-        }
-    }
-    /** Gives number of first verse of citation */
-    verseFromCitation() {
-        var _a;
-        const matches = (_a = (this.citation || '').split(';')[0]) === null || _a === void 0 ? void 0 : _a.match(/[\s\.:](\d+)/g);
-        if (matches) {
-            const [, verse] = matches;
-            return typeof verse === 'string' ? verse.trim().replace(/[\.,:]/g, '') : undefined;
-        }
-        else {
-            return undefined;
-        }
-    }
-    /** Given an abbreviated book name, returns the name of the book
-     * @example
-     * // returns 'Genesis'
-     * this.bookCodeFromAbbrev('Gen') */
-    bookCodeFromAbbrev(a) {
-        if (a) {
-            const abbrev = a.replace(/\./g, ''), searchResult = BIBLE_BOOK_ABBREVIATIONS.find((book) => book.name == abbrev || book.aliases.includes(abbrev) || book.name.includes(abbrev));
-            return searchResult ? searchResult.name : a;
-        }
-        else {
-            return undefined;
-        }
-    }
-    /** Given a book name, returns the full name in the language passed; if not found, returns book name given
-     * @example
-     * // returns 'The Book of Genesis'
-     * this.longNameFromBookCode('Genesis') */
-    longNameFromBookCode(bookName, lang = 'en') {
-        const bookCode = this.bookCodeFromAbbrev(bookName);
-        if (bookCode) {
-            const bookResult = BIBLE_BOOK_NAMES[bookCode];
-            let searchResult = (bookResult || {})[lang];
-            if (!searchResult) {
-                searchResult = (bookResult || {})['en'];
-            }
-            return searchResult ? searchResult.long : bookName;
-        }
-        else {
-            return undefined;
-        }
-    }
-    /** Given a book name, returns the short name in the language passed; if not found, returns book name given
-     * @example
-     * // returns 'Genesis'
-     * this.shortNameFromBookCode('Genesis') */
-    shortNameFromBookCode(bookName, lang = 'en') {
-        var _a;
-        const bookResult = BIBLE_BOOK_NAMES[(_a = this.bookCodeFromAbbrev(bookName)) !== null && _a !== void 0 ? _a : ''], searchResult = (bookResult || {})[lang];
-        return searchResult ? searchResult.short : bookName;
-    }
-    /** Returns the list of all possible `style` values.  */
-    availableStyles() {
-        return STYLES$6;
-    }
-    /** No meaningful difference in display formats for this type */
-    availableDisplayFormats() {
-        return ['default', 'omit'];
-    }
-}
-
-class BibleReadingVerse {
-    constructor(data = {}) {
-        Object.assign(this, data);
-    }
-}
-
-var Book;
-(function (Book) {
-    Book["Genesis"] = "Genesis";
-    Book["Exodus"] = "Exodus";
-    Book["Leviticus"] = "Leviticus";
-    Book["Numbers"] = "Numbers";
-    Book["Deuteronomy"] = "Deuteronomy";
-    Book["Joshua"] = "Joshua";
-    Book["Judges"] = "Judges";
-    Book["Ruth"] = "Ruth";
-    Book["FirstSamuel"] = "FirstSamuel";
-    Book["SecondSamuel"] = "SecondSamuel";
-    Book["FirstKings"] = "FirstKings";
-    Book["SecondKings"] = "SecondKings";
-    Book["FirstChronicles"] = "FirstChronicles";
-    Book["SecondChronicles"] = "SecondChronicles";
-    Book["Ezra"] = "Ezra";
-    Book["Nehemiah"] = "Nehemiah";
-    Book["Esther"] = "Esther";
-    Book["Job"] = "Job";
-    Book["Psalms"] = "Psalms";
-    Book["Proverbs"] = "Proverbs";
-    Book["Ecclesiastes"] = "Ecclesiastes";
-    Book["SongOfSolomon"] = "SongOfSolomon";
-    Book["Isaiah"] = "Isaiah";
-    Book["Jeremiah"] = "Jeremiah";
-    Book["Lamentations"] = "Lamentations";
-    Book["Ezekiel"] = "Ezekiel";
-    Book["Daniel"] = "Daniel";
-    Book["Hosea"] = "Hosea";
-    Book["Joel"] = "Joel";
-    Book["Amos"] = "Amos";
-    Book["Obadiah"] = "Obadiah";
-    Book["Jonah"] = "Jonah";
-    Book["Micah"] = "Micah";
-    Book["Nahum"] = "Nahum";
-    Book["Habakkuk"] = "Habakkuk";
-    Book["Zephaniah"] = "Zephaniah";
-    Book["Haggai"] = "Haggai";
-    Book["Zechariah"] = "Zechariah";
-    Book["Malachi"] = "Malachi";
-    Book["Matthew"] = "Matthew";
-    Book["Mark"] = "Mark";
-    Book["Luke"] = "Luke";
-    Book["John"] = "John";
-    Book["Acts"] = "Acts";
-    Book["Romans"] = "Romans";
-    Book["FirstCorinthians"] = "FirstCorinthians";
-    Book["SecondCorinthians"] = "SecondCorinthians";
-    Book["Galatians"] = "Galatians";
-    Book["Ephesians"] = "Ephesians";
-    Book["Philippians"] = "Philippians";
-    Book["Colossians"] = "Colossians";
-    Book["FirstThessalonians"] = "FirstThessalonians";
-    Book["SecondThessalonians"] = "SecondThessalonians";
-    Book["FirstTimothy"] = "FirstTimothy";
-    Book["SecondTimothy"] = "SecondTimothy";
-    Book["Titus"] = "Titus";
-    Book["Philemon"] = "Philemon";
-    Book["Hebrews"] = "Hebrews";
-    Book["James"] = "James";
-    Book["FirstPeter"] = "FirstPeter";
-    Book["SecondPeter"] = "SecondPeter";
-    Book["FirstJohn"] = "FirstJohn";
-    Book["SecondJohn"] = "SecondJohn";
-    Book["ThirdJohn"] = "ThirdJohn";
-    Book["Jude"] = "Jude";
-    Book["Revelation"] = "Revelation";
-    Book["None"] = "None";
-    Book["Tobit"] = "Tobit";
-    Book["Judith"] = "Judith";
-    Book["Ester"] = "Ester";
-    Book["Wisdom"] = "Wisdom";
-    Book["Ecclesiasticus"] = "Ecclesiasticus";
-    Book["Baruch"] = "Baruch";
-    Book["EpistleJeremiah"] = "EpistleJeremiah";
-    Book["PrayerOfAzariah"] = "PrayerOfAzariah";
-    Book["Susanna"] = "Susanna";
-    Book["FirstMaccabees"] = "FirstMaccabees";
-    Book["SecondMaccabees"] = "SecondMaccabees";
-    Book["FirstEsdras"] = "FirstEsdras";
-    Book["SecondEsdras"] = "SecondEsdras";
-    Book["FourthEsdras"] = "FourthEsdras";
-    Book["Psalm151"] = "Psalm151";
-    Book["ThirdMaccabees"] = "ThirdMaccabees";
-    Book["FourthMaccabees"] = "FourthMaccabees";
-    Book["Bel"] = "Bel";
-})(Book || (Book = {}));
-
-const BOOKS = [
-    ['Genesis', Book.Genesis],
-    ['Exodus', Book.Exodus],
-    ['Leviticus', Book.Leviticus],
-    ['Numbers', Book.Numbers],
-    ['Deuteronomy', Book.Deuteronomy],
-    ['Joshua', Book.Joshua],
-    ['Judges', Book.Judges],
-    ['Ruth', Book.Ruth],
-    ['First Samuel', Book.FirstSamuel],
-    ['Second Samuel', Book.SecondSamuel],
-    ['First Kings', Book.FirstKings],
-    ['Second Kings', Book.SecondKings],
-    ['First Chronicles', Book.FirstChronicles],
-    ['Second Chronicles', Book.SecondChronicles],
-    ['1 Samuel', Book.FirstSamuel],
-    ['2 Samuel', Book.SecondSamuel],
-    ['1 Kings', Book.FirstKings],
-    ['2 Kings', Book.SecondKings],
-    ['1 Chronicles', Book.FirstChronicles],
-    ['1 Chron.', Book.FirstChronicles],
-    ['2 Chronicles', Book.SecondChronicles],
-    ['2 Chron.', Book.SecondChronicles],
-    ['Ezra', Book.Ezra],
-    ['Nehemiah', Book.Nehemiah],
-    ['Esther', Book.Esther],
-    ['Job', Book.Job],
-    ['Psalms', Book.Psalms],
-    ['Proverbs', Book.Proverbs],
-    ['Ecclesiastes', Book.Ecclesiastes],
-    ['Eccl.', Book.Ecclesiastes],
-    ['Song of Solomon', Book.SongOfSolomon],
-    ['Song of Songs', Book.SongOfSolomon],
-    ['Cantic', Book.SongOfSolomon],
-    ['Isaiah', Book.Isaiah],
-    ['Jeremiah', Book.Jeremiah],
-    ['Lamentations', Book.Lamentations],
-    ['Lam', Book.Lamentations],
-    ['Ezekiel', Book.Ezekiel],
-    ['Daniel', Book.Daniel],
-    ['Hosea', Book.Hosea],
-    ['Joel', Book.Joel],
-    ['Amos', Book.Amos],
-    ['Obadiah', Book.Obadiah],
-    ['Jonah', Book.Jonah],
-    ['Micah', Book.Micah],
-    ['Nahum', Book.Nahum],
-    ['Habakkuk', Book.Habakkuk],
-    ['Zephaniah', Book.Zephaniah],
-    ['Haggai', Book.Haggai],
-    ['Zechariah', Book.Zechariah],
-    ['Malachi', Book.Malachi],
-    ['Matthew', Book.Matthew],
-    ['Mark', Book.Mark],
-    ['Luke', Book.Luke],
-    ['John', Book.John],
-    ['Acts', Book.Acts],
-    ['Romans', Book.Romans],
-    ['1 Cor.', Book.FirstCorinthians],
-    ['1 Corinthians', Book.FirstCorinthians],
-    ['First Corinthians', Book.FirstCorinthians],
-    ['2 Cor.', Book.SecondCorinthians],
-    ['2 Corinthians', Book.SecondCorinthians],
-    ['Second Corinthians', Book.SecondCorinthians],
-    ['Galatians', Book.Galatians],
-    ['Ephesians', Book.Ephesians],
-    ['Eph', Book.Ephesians],
-    ['Philippians', Book.Philippians],
-    ['Phil', Book.Philippians],
-    ['Colossians', Book.Colossians],
-    ['Col.', Book.Colossians],
-    ['1 Thessalonians', Book.FirstThessalonians],
-    ['First Thessalonians', Book.FirstThessalonians],
-    ['2 Thessalonians', Book.SecondThessalonians],
-    ['Second Thessalonians', Book.SecondThessalonians],
-    ['1 Timothy', Book.FirstTimothy],
-    ['First Timothy', Book.FirstTimothy],
-    ['1 Tim', Book.FirstTimothy],
-    ['2 Timothy', Book.SecondTimothy],
-    ['Second Timothy', Book.SecondTimothy],
-    ['2 Tim', Book.SecondTimothy],
-    ['Titus', Book.Titus],
-    ['Philemon', Book.Philemon],
-    ['Phlm', Book.Philemon],
-    ['Hebrews', Book.Hebrews],
-    ['James', Book.James],
-    ['1 Peter', Book.FirstPeter],
-    ['First Peter', Book.FirstPeter],
-    ['2 Peter', Book.SecondPeter],
-    ['Second Peter', Book.SecondPeter],
-    ['1 John', Book.FirstJohn],
-    ['2 John', Book.SecondJohn],
-    ['3 John', Book.ThirdJohn],
-    ['First John', Book.FirstJohn],
-    ['Second John', Book.SecondJohn],
-    ['Third John', Book.ThirdJohn],
-    ['Jude', Book.Jude],
-    ['Revelation', Book.Revelation],
-    ['Apocalypse', Book.Revelation],
-    ['Ester', Book.Ester],
-    ['Wisdom', Book.Wisdom],
-    ['Wis. Sol.', Book.Wisdom],
-    ['Wisdom of Solomon', Book.Wisdom],
-    ['Ecclesiasticus', Book.Ecclesiasticus],
-    ['Ecclus.', Book.Ecclesiasticus],
-    ['Baruch', Book.Baruch],
-    ['Epistle of Jeremiah', Book.EpistleJeremiah],
-    ['Ep. Jer.', Book.EpistleJeremiah],
-    ['Prayer of Azariah', Book.PrayerOfAzariah],
-    ['PrAzariah', Book.PrayerOfAzariah],
-    ['Susanna', Book.Susanna],
-    ['First Maccabees', Book.FirstMaccabees],
-    ['Second Maccabees', Book.SecondMaccabees],
-    ['1 Maccabees', Book.FirstMaccabees],
-    ['2 Maccabees', Book.SecondMaccabees],
-    ['First Esdras', Book.FirstEsdras],
-    ['Second Esdras', Book.SecondEsdras],
-    ['Fourth Esdras', Book.FourthEsdras],
-    ['1 Esdras', Book.FirstEsdras],
-    ['2 Esdras', Book.SecondEsdras],
-    ['4 Esdras', Book.FourthEsdras],
-    ['Psalm 151', Book.Psalm151],
-    ['Third Maccabees', Book.ThirdMaccabees],
-    ['Fourth Maccabees', Book.FourthMaccabees],
-    ['3 Maccabees', Book.ThirdMaccabees],
-    ['4 Maccabees', Book.FourthMaccabees],
-    ['Bel', Book.Bel],
-    ['Bel and the Dragon', Book.Bel],
-    ['Judith', Book.Judith],
-];
-
-var lib = createCommonjsModule(function (module, exports) {
-"use strict";
-// Reference: https://www.geeksforgeeks.org/jaro-and-jaro-winkler-similarity/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jaroWinkler = exports.jaro = void 0;
-/**
- *
- * @param str1 String 1 for compare
- * @param str2 String 2 for compare
- * @param options to control case sensitive or not
- */
-function jaro(str1, str2, options) {
-    // Exit early if either are empty.
-    if (str1.length === 0 || str2.length === 0) {
-        return 0;
-    }
-    // Convert to upper if case-sensitive is false.
-    if (options && !options.caseSensitive) {
-        str1 = str1.toUpperCase();
-        str2 = str2.toUpperCase();
-    }
-    // Exact match
-    if (str1 === str2) {
-        return 1;
-    }
-    // Number of matches
-    var m = 0;
-    // Length of two Strings
-    var len1 = str1.length;
-    var len2 = str2.length;
-    // Maximum distance
-    var window = Math.floor(Math.max(len1, len2) / 2) - 1;
-    // Hash for matches
-    var str1Hash = new Array(len1);
-    var str2Hash = new Array(len2);
-    for (var i = 0; i < len1; i++) {
-        for (var j = Math.max(0, i - window); j <= Math.min(len2, i + window + 1); j++) {
-            if (!str1Hash[i] && !str2Hash[j] && str1[i] === str2[j]) {
-                ++m;
-                str1Hash[i] = str2Hash[j] = true;
-                break;
-            }
-        }
-    }
-    // Exit early if no matches were found.
-    if (m === 0) {
-        return 0;
-    }
-    // Count the transpositions.
-    var t = 0;
-    var point = 0;
-    for (var i = 0; i < len1; i++) {
-        if (str1Hash[i]) {
-            while (!str2Hash[point]) {
-                point++;
-            }
-            if (str1.charAt(i) !== str2.charAt(point++)) {
-                t++;
-            }
-        }
-    }
-    t /= 2;
-    return (m / len1 + m / len2 + (m - t) / m) / 3;
-}
-exports.jaro = jaro;
-/**
- *
- * @param str1 String 1 for compare
- * @param str2 String 2 for compare
- * @param options to control case sensitive or not
- */
-function jaroWinkler(str1, str2, options) {
-    // Jaro Distance
-    var jaroDist = jaro(str1, str2, options);
-    // Same prefix length, maxium is 4
-    var prefix = 0;
-    if (jaroDist > 0.7) {
-        var minIndex = Math.min(str1.length, str2.length);
-        var i = 0;
-        while (str1[i] === str2[i] && i < 4 && i < minIndex) {
-            ++prefix;
-            i++;
-        }
-        jaroDist += 0.1 * prefix * (1 - jaroDist);
-    }
-    return jaroDist;
-}
-exports.jaroWinkler = jaroWinkler;
-});
-
-const index = /*@__PURE__*/getDefaultExportFromCjs(lib);
-
-function parseReference(reference) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20;
-    let list = [];
-    let prev = null;
-    let bracketOpened = false;
-    for (let part of reference.split(/([,;\[\]\(\)])/)) {
-        const trimmed = part.trim();
-        if (['', ',', ';', '[', ']', '(', ')'].includes(trimmed)) {
-            if (trimmed == '[' || trimmed == '(') {
-                bracketOpened = true;
-            }
-            else if (trimmed == ']' || trimmed == ')') {
-                bracketOpened = false;
-            }
-        }
-        else {
-            const current = parseSingleReference(part, prev, bracketOpened);
-            list.push(current);
-            prev = current;
-        }
-    }
-    // handle citations like 1 Cor. 13:[1-3]4-13
-    if (((_b = (_a = list[0]) === null || _a === void 0 ? void 0 : _a.start) === null || _b === void 0 ? void 0 : _b.verse) == null && ((_c = list[1]) === null || _c === void 0 ? void 0 : _c.bracketed)) {
-        list = [
-            {
-                start: {
-                    book: (_e = (_d = list[1].start.book) !== null && _d !== void 0 ? _d : list[0].start.book) !== null && _e !== void 0 ? _e : null,
-                    chapter: (_g = (_f = list[1].start.chapter) !== null && _f !== void 0 ? _f : list[0].start.chapter) !== null && _g !== void 0 ? _g : null,
-                    verse: (_j = (_h = list[1].start.verse) !== null && _h !== void 0 ? _h : list[0].start.verse) !== null && _j !== void 0 ? _j : null,
-                },
-                end: {
-                    book: (_w = (_t = (_q = (_m = (_l = (_k = list[1]) === null || _k === void 0 ? void 0 : _k.end) === null || _l === void 0 ? void 0 : _l.book) !== null && _m !== void 0 ? _m : (_p = (_o = list[0]) === null || _o === void 0 ? void 0 : _o.end) === null || _p === void 0 ? void 0 : _p.book) !== null && _q !== void 0 ? _q : (_s = (_r = list[1]) === null || _r === void 0 ? void 0 : _r.start) === null || _s === void 0 ? void 0 : _s.book) !== null && _t !== void 0 ? _t : (_v = (_u = list[0]) === null || _u === void 0 ? void 0 : _u.start) === null || _v === void 0 ? void 0 : _v.book) !== null && _w !== void 0 ? _w : null,
-                    chapter: (_8 = (_5 = (_2 = (_z = (_y = (_x = list[1]) === null || _x === void 0 ? void 0 : _x.end) === null || _y === void 0 ? void 0 : _y.chapter) !== null && _z !== void 0 ? _z : (_1 = (_0 = list[0]) === null || _0 === void 0 ? void 0 : _0.end) === null || _1 === void 0 ? void 0 : _1.chapter) !== null && _2 !== void 0 ? _2 : (_4 = (_3 = list[1]) === null || _3 === void 0 ? void 0 : _3.start) === null || _4 === void 0 ? void 0 : _4.chapter) !== null && _5 !== void 0 ? _5 : (_7 = (_6 = list[0]) === null || _6 === void 0 ? void 0 : _6.start) === null || _7 === void 0 ? void 0 : _7.chapter) !== null && _8 !== void 0 ? _8 : null,
-                    verse: (_20 = (_17 = (_14 = (_11 = (_10 = (_9 = list[1]) === null || _9 === void 0 ? void 0 : _9.end) === null || _10 === void 0 ? void 0 : _10.verse) !== null && _11 !== void 0 ? _11 : (_13 = (_12 = list[0]) === null || _12 === void 0 ? void 0 : _12.end) === null || _13 === void 0 ? void 0 : _13.verse) !== null && _14 !== void 0 ? _14 : (_16 = (_15 = list[1]) === null || _15 === void 0 ? void 0 : _15.start) === null || _16 === void 0 ? void 0 : _16.verse) !== null && _17 !== void 0 ? _17 : (_19 = (_18 = list[0]) === null || _18 === void 0 ? void 0 : _18.start) === null || _19 === void 0 ? void 0 : _19.verse) !== null && _20 !== void 0 ? _20 : null,
-                },
-                bracketed: true,
-            },
-            ...list.slice(2),
-        ];
-    }
-    return list;
-}
-function parseSingleReference(reference, previous, bracketed) {
-    var _a;
-    let range_pieces = reference.split('-');
-    const first_half = range_pieces[0];
-    const second_half = range_pieces[1];
-    const start_partial_structure = previous !== null;
-    const BLANK_REF = { book: null, chapter: null, verse: null };
-    const start = first_half
-        ? (_a = queryFromRe(first_half, /([\d\s]*[\w\.]+[a-zA-Z\s]*)\s*(\d+)?:?(\d+)?/, start_partial_structure, null)) !== null && _a !== void 0 ? _a : Object.assign({}, BLANK_REF) : Object.assign({}, BLANK_REF);
-    // fill out the start of the range with the details of the end of the previous range
-    // e.g., 1 Tim. 4:1-3, 4-6 will fill out with 1 Tim., chapter 4
-    const previous_end = (previous === null || previous === void 0 ? void 0 : previous.end) || null;
-    const augmented_start = fillOut(start, previous_end);
-    const end = second_half ? queryFromRe(second_half, /([\d\s]*[\w\.]+)\s*(\d+)?:?(\d+)?/, true, augmented_start) : null;
-    return {
-        start: augmented_start || start,
-        end,
-        bracketed: bracketed ? true : undefined,
-    };
-}
-function queryFromRe(reference, re, partial_structure, template) {
-    let query = null;
-    const parts = reference.trim().match(re);
-    if (partial_structure) {
-        if (parts) {
-            // book, chapter, and verse matched
-            if (parts[1] && parseInt(parts[2]) && parseInt(parts[3])) {
-                query = { book: book_name_to_book(parts[1]), chapter: parseInt(parts[2]), verse: parseInt(parts[3]) };
-            }
-            // chapter and verse matched
-            else if (parseInt(parts[1]) && !parts[2] && parseInt(parts[3])) {
-                query = { book: null, chapter: parseInt(parts[1]), verse: parseInt(parts[3]) };
-            }
-            else if (parseInt(parts[1]) && parseInt(parts[2]) && !parts[3]) {
-                query = { book: null, chapter: parseInt(parts[1]), verse: parseInt(parts[2]) };
-            }
-            // verse only
-            else if (parseInt(parts[1]) && !parts[2] && !parts[3]) {
-                query = { book: null, chapter: null, verse: parseInt(parts[1]) };
-            }
-        }
-        else {
-            query = null;
-        }
-    }
-    else {
-        const matches = reference.trim().match(re) || [];
-        query = {
-            book: book_name_to_book(matches[1]),
-            chapter: parseInt(matches[2]),
-            verse: parseInt(matches[3]),
-        };
-    }
-    return fillOut(query, template);
-}
-function fillOut(query, template) {
-    // if template provided, fill out query as needed
-    return {
-        book: (query === null || query === void 0 ? void 0 : query.book) || (template === null || template === void 0 ? void 0 : template.book) || null,
-        chapter: (query === null || query === void 0 ? void 0 : query.chapter) || (template === null || template === void 0 ? void 0 : template.chapter) || null,
-        verse: (query === null || query === void 0 ? void 0 : query.verse) || (template === null || template === void 0 ? void 0 : template.verse) || null,
-    };
-}
-// Use Jaro-algorithm string-similarities to determine book name
-function book_name_to_book(book_name) {
-    const scores = BOOKS.map(([key]) => lib.jaro(key, book_name, { caseSensitive: false })), highest = Math.max(...scores), indexOfHighest = scores.indexOf(highest), [, book] = BOOKS[indexOfHighest];
-    return book;
-}
-
-class LectionaryEntry {
-}
-
-class HolyDay {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        Object.assign(this, data);
-    }
-}
-
-/** Represents a particular liturgical or sanctoral calendar */
-class Kalendar {
-}
-
-class LiturgicalColor {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        Object.assign(this, data);
-    }
-}
-
-class LiturgicalWeek {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        /** Used for English-language formatting, generally when "week" name is the proper name of a Sunday.
-         * @example
-         * // "Thursday after Pentecost", not "Thursday after the Pentecost" */
-        this.omit_the = false;
-        Object.assign(this, data);
-    }
-}
-
-/** Holds instructions on how to adapt liturgies given the Proper Liturgies for Special Days
- * e.g., Ash Wednesday, */
-class ProperLiturgy {
-}
-
-const SEASONS = [
-    'Advent',
-    'Christmas',
-    'Epiphany',
-    'Lent',
-    'HolyWeek',
-    'Easter',
-    'Ascension',
-    'Pentecost',
-    'Saints',
-    'OrdinaryTime',
-    'Ember',
-    'National',
-    'Rogation',
-    'Mary',
-];
-
-class CanticleTableEntry {
-}
-
-function filterCanticleTableEntries(entries, day, whichTable, nth, fallbackTable = undefined, defaultCanticles = undefined) {
-    const isFeast = day instanceof LiturgicalDay ? day.isFeast() : new LiturgicalDay(day).isFeast(), isEvening = day.evening, date = dateFromYMDString(day.date), dayOfWeek = date.getDay(), days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'], weekday = isFeast ? 'FeastDay' : days[dayOfWeek];
-    const primaryEntries = fallbackTable ? entries.filter((entry) => entry.table == whichTable) : entries, primaryWeekdayEntries = primaryEntries.filter((entry) => !(entry === null || entry === void 0 ? void 0 : entry.weekday) || (entry === null || entry === void 0 ? void 0 : entry.weekday) == weekday), 
-    // if not found, try fallback table
-    weekdayEntries = primaryWeekdayEntries.length == 0 && fallbackTable
-        ? primaryEntries.filter((entry) => (entry === null || entry === void 0 ? void 0 : entry.table) == fallbackTable && (!(entry === null || entry === void 0 ? void 0 : entry.weekday) || (entry === null || entry === void 0 ? void 0 : entry.weekday) == weekday))
-        : primaryWeekdayEntries, 
-    // if entry specifies `season`, `week`, `day`, or `evening`, they must match
-    filteredEntries = weekdayEntries.filter((entry) => entry &&
-        (!entry.season || entry.season == day.season) &&
-        (!entry.week || entry.week == day.week.slug) &&
-        (!entry.day || entry.day == day.slug) &&
-        entry.evening == isEvening), 
-    // find based on day with highest precedence, then week, then season, then just take whatever's there
-    dayEntries = filteredEntries.filter((e) => e.day == day.slug), weekEntries = filteredEntries.filter((e) => e.week == day.week.slug), seasonEntries = filteredEntries.filter((e) => e.season == day.season);
-    let preferredEntries = filteredEntries;
-    if ((dayEntries === null || dayEntries === void 0 ? void 0 : dayEntries.length) > 0) {
-        preferredEntries = dayEntries;
-    }
-    else if ((weekEntries === null || weekEntries === void 0 ? void 0 : weekEntries.length) > 0) {
-        preferredEntries = weekEntries;
-    }
-    else if ((seasonEntries === null || seasonEntries === void 0 ? void 0 : seasonEntries.length) > 0) {
-        preferredEntries = seasonEntries;
-    }
-    if ((preferredEntries === null || preferredEntries === void 0 ? void 0 : preferredEntries.length) == 0 && fallbackTable) {
-        return filterCanticleTableEntries(entries, day, fallbackTable, nth, undefined, defaultCanticles);
-    }
-    else if ((preferredEntries === null || preferredEntries === void 0 ? void 0 : preferredEntries.length) == 0 && defaultCanticles !== undefined) {
-        const defaultCanticle = new CanticleTableEntry();
-        return new Array(Object.assign(Object.assign({}, defaultCanticle), { slug: defaultCanticles[isEvening ? 'evening' : 'morning'][nth] }));
-    }
-    else {
-        return preferredEntries;
-    }
-}
-
-class Citation {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        /** The URL (as a string) for the API from which more information about the source can be found */
-        this.api = 'https://www.venite.app/api';
-        Object.assign(this, data);
-    }
-    /** Provides a human-readable string form of the citation */
-    toString(suppressSource = false) {
-        return suppressSource ? this.citation : `${this.source} ${this.citation}`;
-    }
-}
-
-class SelectableCitation {
-}
-
-class Source {
-}
-
-const STYLES$5 = ['text', 'day', 'date'];
-class Heading extends LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        super(data);
-    }
-    /** Returns the list of all possible `style` values.  */
-    availableStyles() {
-        return STYLES$5;
-    }
-    /** No meaningful difference in display formats for this type */
-    availableDisplayFormats() {
-        return [];
-    }
-}
-
-const STYLES$4 = ['normal', 'slideshow', 'carousel'];
-/** Refrain represents a short text like the Gloria Patri, Hail Mary, or an Antiphon */
-class Image extends LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        super(data);
-    }
-    /** Returns the list of all possible `style` values. Child classes should override if they have styles available. */
-    availableStyles() {
-        return STYLES$4;
-    }
-    availableDisplayFormats() {
-        return [];
-    }
-}
-
-/** Represents the "recipe" to compile a liturgy */
-class Liturgy extends LiturgicalDocument {
-    /** No meaningful differences in display format for liturgies */
-    availableDisplayFormats() {
-        return [];
-    }
-}
-
-/** `Preference` represents a single preference in any given liturgy */
-class Preference {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        Object.assign(this, data);
-    }
-    /** Given a `value` for the preference, returns the full option */
-    getPreferenceOption(value) {
-        return this.options.find((option) => option.value == value);
-    }
-    /** Returns the default value for the preference */
-    getDefaultPref() {
-        const defaultPref = this.options.filter((opt) => opt.default)[0], firstPref = this.options[0];
-        return (defaultPref || firstPref).value;
-    }
-}
-class PreferenceOption {
-}
-
-class ClientPreferences {
-}
-
-class Meditation extends LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        super(data);
-    }
-}
-
-function versionToString(version) {
-    if (typeof version === 'string') {
-        return version;
-    }
-    else {
-        return JSON.stringify(version);
-    }
-}
-
-const VERSIONS = {
-    ip: 'IP',
-    bcp1979: 'Rite II',
-    bcp1979_psalm: '1979',
-    eow: 'EOW',
-    coverdale: 'Coverdale',
-    rite_i: 'Rite I',
-};
-function modifiedVersion(option) {
-    return option.type === 'psalm' && option.style === 'psalm' && option.version === 'bcp1979'
-        ? 'bcp1979_psalm'
-        : option.version;
-}
-class Option extends LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        super(data);
-    }
-    availableDisplayFormats() {
-        return [];
-    }
-    uniqueVersions() {
-        return (this.value || [])
-            .map((o) => versionToString(o.version))
-            .reduce((uniques, item) => (uniques.includes(item) ? uniques : [...uniques, item]), []).length;
-    }
-    uniqueLabels() {
-        return (this.value || [])
-            .map((o) => o.label)
-            .reduce((uniques, item) => (uniques.includes(item) ? uniques : [...uniques, item]), []).length;
-    }
-    uniqueCitations() {
-        return (this.value || [])
-            .map((o) => (o.citation ? o.citation.toString() : ''))
-            .filter((citation) => !!citation)
-            .reduce((uniques, item) => (uniques.includes(item) ? uniques : [...uniques, item]), []).length;
-    }
-    uniqueCanticleNumbers() {
-        return Array.from(new Set((this.value || []).map((o) => { var _a; return (o.style === 'canticle' ? (_a = o.metadata) === null || _a === void 0 ? void 0 : _a.number : o.slug || Math.random()); }))).length;
-    }
-    /** Gives an appropriate version label for the document given */
-    getVersionLabel(option, maxLength = 50) {
-        var _a, _b, _c;
-        const uniqueVersions = this.uniqueVersions(), uniqueLabels = this.uniqueLabels(), uniqueCitations = this.uniqueCitations(), uniqueCanticleNumbers = this.uniqueCanticleNumbers();
-        let label = '';
-        if (option.type == 'liturgy') {
-            label = option.label || option.version_label || 'Option';
-        }
-        // Psalm 119 parts => Psalm 119: Aleph
-        else if (option.type == 'psalm' &&
-            uniqueVersions == 1 &&
-            option.label &&
-            (((_a = option.slug) === null || _a === void 0 ? void 0 : _a.match(/psalm_119_/)) || ((_b = option.citation) === null || _b === void 0 ? void 0 : _b.toString().match(/Ps[^\d]+119/)))) {
-            label = option.label;
-        }
-        // Other psalms: Psalm 121
-        else if (option.type == 'psalm' &&
-            option.style == 'psalm' &&
-            (option.citation || ((_c = option.metadata) === null || _c === void 0 ? void 0 : _c.number)) &&
-            uniqueVersions == 1) {
-            label = option.citation ? option.citation.toString() : `Psalm ${option.metadata.number}`;
-        }
-        // Readings of many citations => include truncated text
-        else if (option.type == 'bible-reading' &&
-            uniqueCitations > 1 &&
-            option.citation &&
-            option.value &&
-            option.value.length > 0) {
-            const text = option.value
-                .map((v) => (v.hasOwnProperty('text') ? v.text : v.toString()))
-                .join(' ');
-            const formattedText = option.style == 'short' ? ` (“${text}”)` : '';
-            if (uniqueVersions > 1) {
-                label = `${option.citation.toString()} (${option.version})${formattedText}`;
-            }
-            else {
-                label = `${option.citation.toString()}${formattedText}`;
-            }
-        }
-        // Readings with same citation + different versions => Version
-        else if (option.type == 'bible-reading' && uniqueCitations == 1) {
-            label = versionToString(option.version);
-        }
-        // Readings with one version => John 1:1-4
-        else if (option.type == 'bible-reading' && option.citation && uniqueVersions == 1) {
-            label = option.citation.toString();
-        }
-        // Readings with multiple versions => John 1:1-4 (Version)
-        else if (option.type == 'bible-reading' && option.citation && uniqueVersions > 1) {
-            label = `${option.citation.toString()} (${versionToString(option.version)})`;
-        }
-        // Canticles, if only one version
-        else if (uniqueVersions == 1 &&
-            option.type == 'psalm' &&
-            option.style == 'canticle' &&
-            option.metadata &&
-            option.metadata.localname) {
-            label = option.metadata.localname;
-        }
-        // Canticles, if multiple options for same number
-        else if (uniqueVersions > 1 && uniqueCanticleNumbers === 1) {
-            label = VERSIONS[versionToString(modifiedVersion(option))];
-        }
-        // Canticles and invitatories, if multiple options => Venite (EOW)
-        else if (uniqueVersions > 1 && option.metadata && option.metadata.hasOwnProperty('localname') && option.version) {
-            label = `${option.metadata.localname} (${VERSIONS[versionToString(modifiedVersion(option))]})`;
-        }
-        // Version label other than BCP 1979 => EOW
-        else if (option.version_label && option.version_label !== 'bcp1979') {
-            label = option.version_label;
-        }
-        // If multiple labels, then label => Trisagion, Gloria in Excelsis, Kyrie
-        else if (option.label && uniqueLabels > 1 && uniqueVersions == 1) {
-            label = option.label;
-        }
-        // If multiple labels and version, then label (version) => Trisagion (BCP), Gloria in Excelsis (EOW)
-        else if (option.label && uniqueLabels > 1 && uniqueVersions > 1) {
-            label = `${option.label} (${VERSIONS[versionToString(modifiedVersion(option))]})`;
-        }
-        // Local name but no version (or version is BCP) => 'The Song of Mary'
-        else if (option.metadata &&
-            option.metadata.hasOwnProperty('localname') &&
-            (!option.version_label || option.version_label == 'bcp1979')) {
-            label = option.metadata.localname;
-        }
-        // Fall back to a version label
-        else if (uniqueVersions > 1 && option.version) {
-            label = VERSIONS[versionToString(modifiedVersion(option))];
-        }
-        // Fall back to a citation
-        else if (option.citation) {
-            label = option.citation.toString();
-        }
-        // Fallback: stripped version of JSON of value
-        else if (option.value) {
-            label = `“${JSON.stringify(option.value)
-                .replace(/[\[\]\{\}\"\'\:]/g, ' ')
-                .replace(/\\n/g, ' ')
-                .trim()}”`;
-        }
-        else {
-            throw `Unable to generate a label from ${JSON.stringify(option)}`;
-        }
-        return label.length > maxLength ? label.substring(0, maxLength) + '...' : label;
-    }
-}
-
-class Parallel extends LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        super(data);
-    }
-}
-
-const STYLES$3 = ['psalm', 'canticle', 'invitatory'];
-/** Psalm represents liturgical instructions. */
-class Psalm extends LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        super(data);
-    }
-    /** Returns a filtered list of verses based on citation */
-    filteredVerses() {
-        let filtered = new Array();
-        if (this.citation && (this.citation.match(/Ps[^\s]*\s*\d+/) || this.citation == '')) {
-            const versesInCitation = this.versesInCitation(this.citation);
-            if (versesInCitation.length == 0) {
-                /* if `versesInCitation` is empty, it's probably because
-                 * something like 'Psalm 80' was passed as citation */
-                filtered = this.value;
-            }
-            else {
-                (this.value || []).forEach((section) => {
-                    const newSection = new Array();
-                    // okay, this is O(4n)...
-                    (section.value || []).forEach((verse) => {
-                        if (!verse.number || versesInCitation.includes(verse.number)) {
-                            newSection.push(verse);
-                        }
-                        else if (versesInCitation.includes(`[${verse.number}`)) {
-                            newSection.push(Object.assign(Object.assign({}, verse), { verse: '[' + verse.verse }));
-                        }
-                        else if (versesInCitation.includes(`${verse.number}]`)) {
-                            newSection.push(Object.assign(Object.assign({}, verse), { halfverse: verse.halfverse + ']' }));
-                        }
-                        else if (versesInCitation.includes(`[${verse.number}]`)) {
-                            newSection.push(Object.assign(Object.assign({}, verse), { verse: '[' + verse.verse, halfverse: verse.halfverse + ']' }));
-                        }
-                    });
-                    filtered.push(Object.assign(Object.assign({}, section), { value: newSection }));
-                });
-            }
-        }
-        else {
-            filtered = this.value;
-        }
-        return filtered;
-    }
-    /** Transforms an ordinary citation into a list of included verse numbers
-     * @example
-     * // returns ['1', '2', '3', '6', '7', '11']
-     * versesInCitation('Psalm 100:1-3,6-7, 11a')
-     * */
-    versesInCitation(citation) {
-        function makeVerseNumber(startBracket, endBracket, num) {
-            if (startBracket && endBracket) {
-                return '[' + num + ']';
-            }
-            else if (startBracket) {
-                return '[' + num;
-            }
-            else if (endBracket) {
-                return num + ']';
-            }
-            else {
-                return num;
-            }
-        }
-        // comments assume versesInCitation('Psalm 100:1-3,6-7, 11a')
-        // search = [ "Psalm 100", "1-3", "6-7", "11a" ]
-        const search = citation.replace(/Ps[\w\.]*\s*/g, '').split(/\s*([\[\]\(\),:\s])\s*/), 
-        // whole = 'Psalm 100', psalm = 'Psalm', number = '100'
-        // [whole, psalm, number] = search[0].match(/(Ps[^\s]*)\s(\d+)/),
-        // verseRanges = [ "1-3", "6-7", "11a" ]
-        verseRanges = search.slice(1);
-        let verses = new Array();
-        let startBracket = false;
-        let endBracket = false;
-        (verseRanges || []).forEach((range, rangeIndex) => {
-            if (range === '[' || range === '(') {
-                startBracket = true;
-            }
-            if (verseRanges[rangeIndex + 1] === ']' || verseRanges[rangeIndex + 1] === ')') {
-                endBracket = true;
-            }
-            const [first, last] = range.replace(/[^\d-s–]/g, '').split(/-|–/);
-            if (first && last) {
-                const hasEndBracket = endBracket;
-                for (let ii = parseInt(first); ii <= parseInt(last); ii++) {
-                    endBracket = hasEndBracket && ii == parseInt(last);
-                    verses.push(makeVerseNumber(startBracket, endBracket, ii.toString()));
-                    startBracket = false;
-                }
-            }
-            else {
-                if (first) {
-                    verses.push(makeVerseNumber(startBracket, endBracket, first));
-                    startBracket = false;
-                }
-                endBracket = false;
-            }
-        });
-        return verses;
-    }
-    /** Whether the antiphon should be included */
-    includeAntiphon() {
-        const metadata = this.metadata || {};
-        return (!!metadata.antiphon && !metadata.omit_antiphon // must have an antiphon
-        ); //&& // if we're supposed to omit it, omit it
-        //!(this.style == 'canticle' && !metadata.omit_gloria);
-    }
-    /** Whether the antiphon should be repeated after a section of the given index */
-    repeatAntiphon(setIndex, filteredValueLength = 0) {
-        const metadata = this.metadata || {};
-        if (filteredValueLength == 0) {
-            filteredValueLength = this.filteredVerses().length;
-        }
-        return (this.includeAntiphon() && // only if there's an antiphon
-            !((metadata.omit_gloria && setIndex == filteredValueLength - 1) // antiphon will repeat after Gloria, so don't include it here as well
-            )); // if there's no Gloria, and this is the final set
-    }
-    /** Returns the list of all possible `style` values.  */
-    availableStyles() {
-        return STYLES$3;
-    }
-    /** Returns the list ofall possible `display_format` values. */
-    availableDisplayFormats() {
-        return ['default', 'omit', 'unison', 'wholeverse', 'halfverse'];
-    }
-}
-/** Section breaks can be used to introduce a heading, or to indicate a place for an antiphon to be inserted  */
-class PsalmSection {
-}
-/** PsalmVerse is a single verse or line
- * @example
- * // 1  The Lord is my shepherd; *
- * //      I shall not be in want.
- * { number: "1", verse: "The Lord is my shepherd; *", halfverse: "I shall not be in want."}
- * */
-class PsalmVerse {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        Object.assign(this, data);
-    }
-}
-
-const STYLES$2 = ['normal', 'antiphon', 'gloria'];
-/** Refrain represents a short text like the Gloria Patri, Hail Mary, or an Antiphon */
-class Refrain extends LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        super(data);
-    }
-    /** Returns the list of all possible `style` values. Child classes should override if they have styles available. */
-    availableStyles() {
-        return STYLES$2;
-    }
-    availableDisplayFormats() {
-        return [];
-    }
-}
-
-const STYLES$1 = ['preces', 'litany', 'responsive'];
-/** Text represents collect or any other short prayer. */
-class ResponsivePrayer extends LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        super(data);
-    }
-    /** Returns the list of all possible `style` values. */
-    availableStyles() {
-        return STYLES$1;
-    }
-    availableDisplayFormats() {
-        return [];
-    }
-}
-/** One line of a responsive prayer
- * @example
- * { label: '℣', text: 'Lord, open my lips.' }
- * @example
- * { label: 'line', text: 'That this evening may be holy, good, and peaceful.' }
- */
-class ResponsivePrayerLine {
-}
-
-/** Rubric represents liturgical instructions. */
-class Rubric extends LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        super(data);
-    }
-    availableDisplayFormats() {
-        return [];
-    }
-}
-
-class Sharing {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        Object.assign(this, data);
-    }
-}
-
-const STYLES = ['text', 'prayer', 'markdown', 'authorized-prayers'];
-/** Text represents collect or any other short prayer. */
-class Text extends LiturgicalDocument {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        super(data);
-    }
-    /** Returns the list of all possible `style` values. */
-    availableStyles() {
-        return STYLES;
-    }
-}
-
-class DisplaySettings {
-    constructor(dropcaps = 'plain', response = 'bold', repeatAntiphon = 'bracket', fontscale = 'm', font = 'garamond', voiceChoice = '', voiceRate = 0.85, voiceBackground = 'silence', voiceBackgroundVolume = 0.5, psalmVerses = false, bibleVerses = false, meditationBell = 'singing-bowl', darkmode = 'auto', bolded = 'both', psalmPause = 1000) {
-        this.dropcaps = dropcaps;
-        this.response = response;
-        this.repeatAntiphon = repeatAntiphon;
-        this.fontscale = fontscale;
-        this.font = font;
-        this.voiceChoice = voiceChoice;
-        this.voiceRate = voiceRate;
-        this.voiceBackground = voiceBackground;
-        this.voiceBackgroundVolume = voiceBackgroundVolume;
-        this.psalmVerses = psalmVerses;
-        this.bibleVerses = bibleVerses;
-        this.meditationBell = meditationBell;
-        this.darkmode = darkmode;
-        this.bolded = bolded;
-        this.psalmPause = psalmPause;
-    }
-}
-
-class Cursor {
-    constructor(path, start, end, element) {
-        this.path = path;
-        this.start = start;
-        this.end = end;
-        this.element = element;
-    }
-}
-
-class Operation {
-}
-class Change {
-    //** Constructor takes a Javascript object containing the class's properties */
-    constructor(data = {}) {
-        Object.assign(this, data);
-    }
-    fullyPathedOp() {
-        const p = this.path
-            ? this.path.split('/').filter((part) => (Number(part) ? Number(part) : part))
-            : new Array();
-        return this.op.map((op) => (Object.assign(Object.assign({}, op), { p })));
-    }
-}
-
-class ChangeMessage {
-}
-
-class CursorMessage {
-}
-
-function categoriesToPreferenceTree(categories, preferences) {
-    return categories.reduce((obj, category) => (Object.assign(Object.assign({}, obj), { [category]: Object.entries(preferences)
-            .map(([key, pref]) => new Preference(Object.assign(Object.assign({}, pref), { key })))
-            .filter((pref) => pref.category == category || (!pref.category && category == 'Preferences'))
-            .sort((a, b) => (a.index && b.index ? (a.index < b.index ? -1 : 1) : a.label < b.label ? -1 : 1)) })), {});
-}
-
-/* Converts a list of documents into a single document including all the documents in serial */
-function docsToLiturgy(docs) {
-    const uniqueLabels = docs
-        .map((o) => o === null || o === void 0 ? void 0 : o.label)
-        .reduce((uniques, item) => (uniques.includes(item) ? uniques : [...uniques, item]), []).length;
-    return (docs === null || docs === void 0 ? void 0 : docs.length) > 1
-        ? // if multiple LiturgicalDocuments given, return a Liturgy made up of them
-            new Liturgy({
-                type: 'liturgy',
-                value: docs,
-                label: docs[0] ? docs[0].label : undefined,
-            })
-        : // if only one LiturgicalDocument given, return that document
-            docs[0];
-}
-
-/* Converts a list of documents into a single document showing options in parallel */
-function docsToOption(d, versions = undefined) {
-    if (Array.isArray(d)) {
-        // remove duplicates if literally same JSON
-        const docs = Array.from(new Set(d.map((doc) => JSON.stringify(doc)))).map((doc) => new LiturgicalDocument(JSON.parse(doc)));
-        // sort by preferred version
-        let sorted;
-        if (versions !== undefined && versions.length > 0) {
-            sorted = docs.sort((a, b) => versions.indexOf(versionToString(a.version)) - versions.indexOf(versionToString(b.version)));
-        }
-        else {
-            sorted = docs;
-        }
-        return (sorted === null || sorted === void 0 ? void 0 : sorted.length) > 1
-            ? // if multiple LiturgicalDocuments given, return an Option made up of them
-                new Option({
-                    type: 'option',
-                    metadata: { selected: 0 },
-                    value: sorted,
-                })
-            : // if only one LiturgicalDocument given, return that document
-                sorted[0];
-    }
-    else {
-        return d;
-    }
-}
-
-const FAKE_SEASONS = ['Saints', 'Mary'];
-/** Given a set of all possible collects and a `LiturgicalDay`, returns a `LiturgicalDocument` of the correct collect or sequence of collects */
-function findCollect(collects, day, sundayFirst = true, emberDayPrecedesSunday = false, allSaintsSuppressesCollectOfTheDayUnlessSunday = false, allSaintsOctaveSuppressesCollectOfTheDayUnlessSunday = false, allowMultiple = true, sundayRedLetterDaysAlsoIncludeSundayCollect = false) {
-    var _a, _b, _c;
-    const date = dateFromYMDString(day.date), observedDay = day.collect || day.propers || day.slug, isAllSaintsOctave = date.getMonth() === 10 && date.getDate() === 8, isInOctaveOfAllSaints = date.getMonth() === 10 && date.getDate() >= 1 && date.getDate() <= 8, suppressSundayCollect = (allSaintsSuppressesCollectOfTheDayUnlessSunday && isInOctaveOfAllSaints && date.getDay() !== 0) ||
-        (allSaintsOctaveSuppressesCollectOfTheDayUnlessSunday && isAllSaintsOctave && date.getDay() !== 0), redLetterCollects = collects.filter((collect) => collect.slug === observedDay), redLetterCollect = redLetterCollects.length > 0 ? docsToOption(redLetterCollects) : null, sundaySlug = ((_a = day.week) === null || _a === void 0 ? void 0 : _a.propers) || ((_b = day.week) === null || _b === void 0 ? void 0 : _b.slug), sundayCollects = collects.filter((collect) => collect.slug === sundaySlug), sundayCollect = !suppressSundayCollect && sundayCollects.length > 0 ? docsToOption(sundayCollects) : null, season = !FAKE_SEASONS.includes(day.season) ? day.season : ((_c = day.week) === null || _c === void 0 ? void 0 : _c.season) || day.season, seasonalCollects = collects.filter((collect) => collect.slug === season), octaveCollect = day.octave ? docsToOption(collects.filter((collect) => collect.slug === day.octave)) : null, blackLetterDays = (day.holy_days || []).filter((feast) => feast.type && feast.type.rank < 3), blackLetterCollects = blackLetterDays.map((holyday) => docsToOption((holyday.category || [])
-        .map((category) => collects
-        .filter((collect) => collect.slug === category)
-        .map((collect) => (collect.type === 'text' ? processCollectText(collect, holyday) : collect)))
-        .concat(collects.filter((collect) => { var _a; return collect.slug === holyday.slug && !((_a = holyday.category) === null || _a === void 0 ? void 0 : _a.includes(holyday.slug)); }))
-        .flat())), redLetterOrSunday = redLetterCollect || sundayCollect, 
-    // don't include the seasonal collect if it's the same as the Sunday, i.e., on the First Sunday of Advent
-    observedSeasonalCollect = seasonalCollects
-        ? docsToLiturgy(seasonalCollects.filter((collect) => {
-            const collectValue = JSON.stringify(collect.value);
-            return (collectValue !== JSON.stringify(redLetterOrSunday === null || redLetterOrSunday === void 0 ? void 0 : redLetterOrSunday.value) &&
-                blackLetterCollects
-                    .filter((blCollect) => Boolean(blCollect))
-                    .map((blCollect) => JSON.stringify(blCollect.value))
-                    .reduce((prev, curr) => prev && curr !== collectValue, true));
-        }))
-        : null, 
-    // don't include the octave collect if it's the same as the collect of the day
-    observedOctaveCollect = octaveCollect && JSON.stringify(octaveCollect.value) !== JSON.stringify(redLetterOrSunday === null || redLetterOrSunday === void 0 ? void 0 : redLetterOrSunday.value)
-        ? octaveCollect
-        : null;
-    if (redLetterOrSunday || blackLetterCollects.length > 0) {
-        if (sundayFirst || date.getDay() === 0) {
-            const collects = [
-                redLetterCollect || sundayCollect,
-                redLetterCollect &&
-                    sundayRedLetterDaysAlsoIncludeSundayCollect &&
-                    JSON.stringify(redLetterCollect.value) !== JSON.stringify(sundayCollect === null || sundayCollect === void 0 ? void 0 : sundayCollect.value) &&
-                    (date.getDay() === 0 || (date.getDay() == 6 && day.evening))
-                    ? new LiturgicalDocument(Object.assign(Object.assign({}, sundayCollect), { label: day.week.name }))
-                    : undefined,
-                ...blackLetterCollects,
-                observedOctaveCollect,
-                observedSeasonalCollect,
-            ].filter((collect) => !!collect);
-            return docsToLiturgy(filterMultiple(day, collects, allowMultiple));
-        }
-        else {
-            const collects = [
-                // Ember Day seasonal collects precede Sunday collects, others follow (Canada)
-                emberDayPrecedesSunday && (day.season || '').includes('Ember') ? observedSeasonalCollect : null,
-                redLetterCollect,
-                ...blackLetterCollects,
-                redLetterCollect ? undefined : sundayCollect,
-                observedOctaveCollect,
-                !emberDayPrecedesSunday || !(day.season || '').includes('Ember') ? observedSeasonalCollect : null,
-            ].filter((collect) => !!collect);
-            return docsToLiturgy(filterMultiple(day, collects, allowMultiple));
-        }
-    }
-    else {
-        console.warn('(LDF findCollect) Could not find a collect for ', day, 'from the available collects', collects);
-        return null;
-    }
-}
-function filterMultiple(day, collects, allowMultiple) {
-    if (allowMultiple) {
-        return collects;
-    }
-    else {
-        return [
-            collects.find((c) => { var _a; return c.slug === ((_a = day.holy_day_observed) === null || _a === void 0 ? void 0 : _a.slug); }) ||
-                (day.slug !== day.week.slug && collects.find((c) => { var _a; return c.slug === ((_a = (day.holy_days || [])[0]) === null || _a === void 0 ? void 0 : _a.slug); })) ||
-                collects[0],
-        ];
-    }
-}
-function processCollectText(collect, day) {
-    const saintName = (day.name || '').split(/[,;]/)[0], oldValue = collect.value || new Array(), value = oldValue.map((piece) => piece.replace(/N\./g, saintName).replace(/[\[\]]/g, ''));
-    return new Text(Object.assign(Object.assign({}, collect), { value }));
-}
-
-function preferencesToCategories(preferences) {
-    return Object.values(preferences)
-        .map((pref) => pref.category || 'Preferences')
-        .reduce((uniques, item) => (uniques.includes(item) ? uniques : [...uniques, item]), []);
-}
-
-function sortPsalms(a, b) {
-    var _a, _b;
-    function firstVerse(psalm) {
-        const firstSection = psalm.value[0] || new PsalmSection(), firstVerse = firstSection.value[0], firstNumber = firstVerse === null || firstVerse === void 0 ? void 0 : firstVerse.number;
-        return Number(firstNumber) || 0;
-    }
-    let result;
-    try {
-        const sortByNum = Number((_a = a === null || a === void 0 ? void 0 : a.metadata) === null || _a === void 0 ? void 0 : _a.number) - Number((_b = b === null || b === void 0 ? void 0 : b.metadata) === null || _b === void 0 ? void 0 : _b.number);
-        let sortByVerse = undefined;
-        // if psalms are same number, sort by
-        if (sortByNum === 0) {
-            const firstVerseOfA = firstVerse(a), firstVerseOfB = firstVerse(b);
-            sortByVerse = firstVerseOfA - firstVerseOfB;
-        }
-        result = sortByVerse || sortByNum;
-    }
-    catch (e) {
-        console.warn('sortPsalms was unable to determine which of these two psalms should be placed first: ', a, b);
-        console.warn(e);
-        result = 0;
-    }
-    return result;
-}
-
-/** Transforms a generic `LiturgicalDocument` (either a class instance or an `Object` that matches the type),
- * into an instance of a more-specific inherited class */
-function specificClass(obj) {
-    switch (obj.type) {
-        case 'liturgy':
-            return new Liturgy(obj);
-        case 'heading':
-            return new Heading(obj);
-        case 'option':
-            return new Option(obj);
-        case 'refrain':
-            return new Refrain(obj);
-        case 'rubric':
-            return new Rubric(obj);
-        case 'text':
-            return new Text(obj);
-        case 'responsive':
-            return new ResponsivePrayer(obj);
-        case 'bible-reading':
-            return new BibleReading(obj);
-        case 'psalm':
-            return new Psalm(obj);
-        case 'meditation':
-            return new Meditation(obj);
-        default:
-            return obj;
-    }
-}
-
-function unwrapOptions(doc) {
-    var _a, _b, _c, _d, _e, _f;
-    switch (doc === null || doc === void 0 ? void 0 : doc.type) {
-        case 'option':
-            const filtered = (doc.value || []).filter((entry) => Boolean(entry) && (Boolean(entry.value) || Boolean((entry === null || entry === void 0 ? void 0 : entry.type) === 'bible-reading' && entry.citation)));
-            return unwrapOptions(new LiturgicalDocument(filtered[(_b = (_a = doc.metadata) === null || _a === void 0 ? void 0 : _a.selected) !== null && _b !== void 0 ? _b : 0]));
-        case 'liturgy':
-            return new Liturgy(Object.assign(Object.assign({}, doc), { value: (doc.value || []).map((subDoc) => unwrapOptions(subDoc)) }));
-        case 'psalm':
-            if ((_d = (_c = doc === null || doc === void 0 ? void 0 : doc.metadata) === null || _c === void 0 ? void 0 : _c.gloria) === null || _d === void 0 ? void 0 : _d.type) {
-                doc.metadata.gloria = unwrapOptions(doc.metadata.gloria);
-            }
-            if ((_f = (_e = doc === null || doc === void 0 ? void 0 : doc.metadata) === null || _e === void 0 ? void 0 : _e.antiphon) === null || _f === void 0 ? void 0 : _f.type) {
-                doc.metadata.antiphon = unwrapOptions(doc.metadata.antiphon);
-            }
-            return doc;
-        default:
-            return doc;
-    }
-}
-
-export { BibleReading as B, Change as C, Heading as H, Image as I, Liturgy as L, Meditation as M, Option as O, Psalm as P, Refrain as R, SEASONS as S, Text as T, WEEKDAYS as W, ResponsivePrayer as a, LiturgicalDocument as b, Rubric as c, Condition as d, docsToOption as e, categoriesToPreferenceTree as f, Preference as g, Cursor as h, PreferenceOption as i, Responsive as j, dateFromYMDString as k, LiturgicalDay as l, Citation as m, preferencesToCategories as p, specificClass as s, versionToString as v };