@ambry/scripture 0.0.0-stage → 0.1.0

package/dist/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptureLanguages = exports.findScriptureReferences = exports.parseScriptureReference = exports.scriptureBooks = void 0;
+var books_js_1 = require("./books.js");
+Object.defineProperty(exports, "scriptureBooks", { enumerable: true, get: function () { return books_js_1.scriptureBooks; } });
+var references_js_1 = require("./references.js");
+Object.defineProperty(exports, "parseScriptureReference", { enumerable: true, get: function () { return references_js_1.parseScriptureReference; } });
+Object.defineProperty(exports, "findScriptureReferences", { enumerable: true, get: function () { return references_js_1.findScriptureReferences; } });
+Object.defineProperty(exports, "scriptureLanguages", { enumerable: true, get: function () { return references_js_1.scriptureLanguages; } });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/references.d.ts

@@ -0,0 +1,32 @@
+import { type ScriptureBookCode } from './books.js';
+export type ScriptureLanguage = 'english' | 'greek' | 'latin';
+export type ScriptureReference = {
+    book: string;
+    bookCode: ScriptureBookCode;
+    chapter: number;
+    firstVerse?: number;
+    lastVerse?: number;
+    language?: ScriptureLanguage;
+};
+export type ParseScriptureOptions = {
+    maxVerses?: number;
+};
+export type FindScriptureOptions = ParseScriptureOptions & {
+    maxReferences?: number;
+};
+export declare const scriptureLanguages: {
+    readonly english: {
+        readonly label: "English";
+        readonly field: "english_text";
+    };
+    readonly greek: {
+        readonly label: "Greek";
+        readonly field: "greek_text";
+    };
+    readonly latin: {
+        readonly label: "Latin";
+        readonly field: "latin_text";
+    };
+};
+export declare function parseScriptureReference(input: string, options?: ParseScriptureOptions): ScriptureReference | undefined;
+export declare function findScriptureReferences(content: string, options?: FindScriptureOptions): ScriptureReference[];

package/dist/cjs/references.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptureLanguages = void 0;
+exports.parseScriptureReference = parseScriptureReference;
+exports.findScriptureReferences = findScriptureReferences;
+const books_js_1 = require("./books.js");
+function positiveLimit(value, name) {
+    if (!Number.isSafeInteger(value) || value < 1)
+        throw new RangeError(`${name} must be a positive safe integer.`);
+    return value;
+}
+exports.scriptureLanguages = {
+    english: { label: 'English', field: 'english_text' },
+    greek: { label: 'Greek', field: 'greek_text' },
+    latin: { label: 'Latin', field: 'latin_text' },
+};
+const languagePattern = 'ENGLISH|ENG|EN|GREEK|GRK|GRC|LATIN|LAT|LA';
+const languageSuffixes = {
+    ENGLISH: 'english',
+    ENG: 'english',
+    EN: 'english',
+    GREEK: 'greek',
+    GRK: 'greek',
+    GRC: 'greek',
+    LATIN: 'latin',
+    LAT: 'latin',
+    LA: 'latin',
+};
+const normalizeBook = (name) => name.toLowerCase().replace(/[\s.]/g, '');
+const bookNames = books_js_1.scriptureBooks.flatMap((book) => [book.name, book.code, ...book.aliases].map((name) => ({ name, book })));
+const escapePattern = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const bookPattern = bookNames
+    .map(({ name }) => escapePattern(name).replace(/ /g, '\\s*'))
+    .sort((a, b) => b.length - a.length)
+    .join('|');
+const embeddedReferencePattern = new RegExp(String.raw `(?<![\p{L}\p{N}_])(${bookPattern})\.?\s*(\d{1,3})\s*:\s*(\d{1,3})(?:\s*[-–]\s*(\d{1,3}))?(?:\s+(${languagePattern}))?(?![\p{L}\p{N}_]|\s*[:–-]\s*\d)`, 'giu');
+function parseScriptureReference(input, options = {}) {
+    const maxVerses = positiveLimit(options.maxVerses ?? 176, 'maxVerses');
+    const match = input
+        .trim()
+        .match(new RegExp(String.raw `^(.+?)\s*(\d{1,3})(?:\s*:\s*(\d{1,3})(?:\s*[-–]\s*(\d{1,3}))?)?(?:\s+(${languagePattern}))?$`, 'i'));
+    if (!match)
+        return;
+    const book = bookNames.find(({ name }) => normalizeBook(name) === normalizeBook(match[1]))?.book;
+    const chapter = Number(match[2]);
+    const firstVerse = match[3] ? Number(match[3]) : undefined;
+    const lastVerse = match[4] ? Number(match[4]) : firstVerse;
+    if (!book || chapter < 1 || chapter > 150)
+        return;
+    if (firstVerse != null &&
+        (firstVerse < 1 || lastVerse > 176 || lastVerse < firstVerse || lastVerse - firstVerse + 1 > maxVerses))
+        return;
+    return {
+        book: book.name,
+        bookCode: book.code,
+        chapter,
+        firstVerse,
+        lastVerse,
+        language: languageSuffixes[match[5]?.toUpperCase()] ?? 'english',
+    };
+}
+function findScriptureReferences(content, options = {}) {
+    const maxReferences = positiveLimit(options.maxReferences ?? 10, 'maxReferences');
+    positiveLimit(options.maxVerses ?? 176, 'maxVerses');
+    const trailingLanguage = content.match(new RegExp(String.raw `\b(${languagePattern})\s*[.!?]?\s*$`, 'i'));
+    const defaultLanguage = languageSuffixes[trailingLanguage?.[1].toUpperCase() ?? ''] ?? 'english';
+    const references = [];
+    const seen = new Set();
+    for (const match of content.matchAll(embeddedReferencePattern)) {
+        const reference = parseScriptureReference(match[0], options);
+        if (!reference)
+            continue;
+        if (!match[5])
+            reference.language = defaultLanguage;
+        const key = `${reference.bookCode}:${reference.chapter}:${reference.firstVerse}:${reference.lastVerse}:${reference.language}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        references.push(reference);
+        if (references.length === maxReferences)
+            break;
+    }
+    return references;
+}

package/dist/esm/books.d.ts

@@ -0,0 +1,295 @@
+export declare const scriptureBooks: readonly [{
+    readonly name: "Genesis";
+    readonly code: "gen";
+    readonly aliases: readonly ["Gen"];
+}, {
+    readonly name: "Exodus";
+    readonly code: "exo";
+    readonly aliases: readonly ["Ex", "Exod"];
+}, {
+    readonly name: "Leviticus";
+    readonly code: "lev";
+    readonly aliases: readonly ["Lev"];
+}, {
+    readonly name: "Numbers";
+    readonly code: "num";
+    readonly aliases: readonly ["Num"];
+}, {
+    readonly name: "Deuteronomy";
+    readonly code: "deu";
+    readonly aliases: readonly ["Deut"];
+}, {
+    readonly name: "Joshua";
+    readonly code: "jos";
+    readonly aliases: readonly ["Josh"];
+}, {
+    readonly name: "Judges";
+    readonly code: "jdg";
+    readonly aliases: readonly ["Judg"];
+}, {
+    readonly name: "Ruth";
+    readonly code: "rut";
+    readonly aliases: readonly ["Ruth"];
+}, {
+    readonly name: "1 Samuel";
+    readonly code: "1sa";
+    readonly aliases: readonly ["1 Sam"];
+}, {
+    readonly name: "2 Samuel";
+    readonly code: "2sa";
+    readonly aliases: readonly ["2 Sam"];
+}, {
+    readonly name: "1 Kings";
+    readonly code: "1ki";
+    readonly aliases: readonly ["1 Kgs"];
+}, {
+    readonly name: "2 Kings";
+    readonly code: "2ki";
+    readonly aliases: readonly ["2 Kgs"];
+}, {
+    readonly name: "1 Chronicles";
+    readonly code: "1ch";
+    readonly aliases: readonly ["1 Chron"];
+}, {
+    readonly name: "2 Chronicles";
+    readonly code: "2ch";
+    readonly aliases: readonly ["2 Chron"];
+}, {
+    readonly name: "Ezra";
+    readonly code: "ezr";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Nehemiah";
+    readonly code: "neh";
+    readonly aliases: readonly ["Neh"];
+}, {
+    readonly name: "Tobit";
+    readonly code: "tob";
+    readonly aliases: readonly ["Tob"];
+}, {
+    readonly name: "Judith";
+    readonly code: "jth";
+    readonly aliases: readonly ["Jdt"];
+}, {
+    readonly name: "Esther";
+    readonly code: "est";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Job";
+    readonly code: "job";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Psalms";
+    readonly code: "psa";
+    readonly aliases: readonly ["Psalm", "Ps"];
+}, {
+    readonly name: "Proverbs";
+    readonly code: "pro";
+    readonly aliases: readonly ["Prov"];
+}, {
+    readonly name: "Ecclesiastes";
+    readonly code: "ecc";
+    readonly aliases: readonly ["Eccl"];
+}, {
+    readonly name: "Song of Songs";
+    readonly code: "son";
+    readonly aliases: readonly ["Song of Solomon", "Canticles"];
+}, {
+    readonly name: "Wisdom";
+    readonly code: "wis";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Sirach";
+    readonly code: "sir";
+    readonly aliases: readonly ["Ecclesiasticus"];
+}, {
+    readonly name: "Isaiah";
+    readonly code: "isa";
+    readonly aliases: readonly ["Isa"];
+}, {
+    readonly name: "Jeremiah";
+    readonly code: "jer";
+    readonly aliases: readonly ["Jer"];
+}, {
+    readonly name: "Lamentations";
+    readonly code: "lam";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Baruch";
+    readonly code: "bar";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Ezekiel";
+    readonly code: "eze";
+    readonly aliases: readonly ["Ezek"];
+}, {
+    readonly name: "Daniel";
+    readonly code: "dan";
+    readonly aliases: readonly ["Dan"];
+}, {
+    readonly name: "Hosea";
+    readonly code: "hos";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Joel";
+    readonly code: "joe";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Amos";
+    readonly code: "amo";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Obadiah";
+    readonly code: "oba";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Jonah";
+    readonly code: "jon";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Micah";
+    readonly code: "mic";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Nahum";
+    readonly code: "nah";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Habakkuk";
+    readonly code: "hab";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Zephaniah";
+    readonly code: "zep";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Haggai";
+    readonly code: "hag";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Zechariah";
+    readonly code: "zec";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Malachi";
+    readonly code: "mal";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "1 Maccabees";
+    readonly code: "1ma";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "2 Maccabees";
+    readonly code: "2ma";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Matthew";
+    readonly code: "mat";
+    readonly aliases: readonly ["Mt", "Matt"];
+}, {
+    readonly name: "Mark";
+    readonly code: "mar";
+    readonly aliases: readonly ["Mk"];
+}, {
+    readonly name: "Luke";
+    readonly code: "luk";
+    readonly aliases: readonly ["Lk"];
+}, {
+    readonly name: "John";
+    readonly code: "joh";
+    readonly aliases: readonly ["Jn"];
+}, {
+    readonly name: "Acts";
+    readonly code: "act";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Romans";
+    readonly code: "rom";
+    readonly aliases: readonly ["Rom"];
+}, {
+    readonly name: "1 Corinthians";
+    readonly code: "1co";
+    readonly aliases: readonly ["1 Cor"];
+}, {
+    readonly name: "2 Corinthians";
+    readonly code: "2co";
+    readonly aliases: readonly ["2 Cor"];
+}, {
+    readonly name: "Galatians";
+    readonly code: "gal";
+    readonly aliases: readonly ["Gal"];
+}, {
+    readonly name: "Ephesians";
+    readonly code: "eph";
+    readonly aliases: readonly ["Eph"];
+}, {
+    readonly name: "Philippians";
+    readonly code: "phi";
+    readonly aliases: readonly ["Phil"];
+}, {
+    readonly name: "Colossians";
+    readonly code: "col";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "1 Thessalonians";
+    readonly code: "1th";
+    readonly aliases: readonly ["1 Thess"];
+}, {
+    readonly name: "2 Thessalonians";
+    readonly code: "2th";
+    readonly aliases: readonly ["2 Thess"];
+}, {
+    readonly name: "1 Timothy";
+    readonly code: "1ti";
+    readonly aliases: readonly ["1 Tim"];
+}, {
+    readonly name: "2 Timothy";
+    readonly code: "2ti";
+    readonly aliases: readonly ["2 Tim"];
+}, {
+    readonly name: "Titus";
+    readonly code: "tit";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Philemon";
+    readonly code: "phm";
+    readonly aliases: readonly ["Philem"];
+}, {
+    readonly name: "Hebrews";
+    readonly code: "heb";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "James";
+    readonly code: "jam";
+    readonly aliases: readonly ["Jas"];
+}, {
+    readonly name: "1 Peter";
+    readonly code: "1pe";
+    readonly aliases: readonly ["1 Pet"];
+}, {
+    readonly name: "2 Peter";
+    readonly code: "2pe";
+    readonly aliases: readonly ["2 Pet"];
+}, {
+    readonly name: "1 John";
+    readonly code: "1jo";
+    readonly aliases: readonly ["1 Jn"];
+}, {
+    readonly name: "2 John";
+    readonly code: "2jo";
+    readonly aliases: readonly ["2 Jn"];
+}, {
+    readonly name: "3 John";
+    readonly code: "3jo";
+    readonly aliases: readonly ["3 Jn"];
+}, {
+    readonly name: "Jude";
+    readonly code: "jud";
+    readonly aliases: readonly [];
+}, {
+    readonly name: "Revelation";
+    readonly code: "rev";
+    readonly aliases: readonly ["Apocalypse"];
+}];
+export type ScriptureBook = (typeof scriptureBooks)[number];
+export type ScriptureBookCode = ScriptureBook['code'];

package/dist/esm/books.js

@@ -0,0 +1,80 @@
+// Canonical names and codes from https://api.ambry.church/openapi.json.
+export const scriptureBooks = [
+    { name: 'Genesis', code: 'gen', aliases: ['Gen'] },
+    { name: 'Exodus', code: 'exo', aliases: ['Ex', 'Exod'] },
+    { name: 'Leviticus', code: 'lev', aliases: ['Lev'] },
+    { name: 'Numbers', code: 'num', aliases: ['Num'] },
+    { name: 'Deuteronomy', code: 'deu', aliases: ['Deut'] },
+    { name: 'Joshua', code: 'jos', aliases: ['Josh'] },
+    { name: 'Judges', code: 'jdg', aliases: ['Judg'] },
+    { name: 'Ruth', code: 'rut', aliases: ['Ruth'] },
+    { name: '1 Samuel', code: '1sa', aliases: ['1 Sam'] },
+    { name: '2 Samuel', code: '2sa', aliases: ['2 Sam'] },
+    { name: '1 Kings', code: '1ki', aliases: ['1 Kgs'] },
+    { name: '2 Kings', code: '2ki', aliases: ['2 Kgs'] },
+    { name: '1 Chronicles', code: '1ch', aliases: ['1 Chron'] },
+    { name: '2 Chronicles', code: '2ch', aliases: ['2 Chron'] },
+    { name: 'Ezra', code: 'ezr', aliases: [] },
+    { name: 'Nehemiah', code: 'neh', aliases: ['Neh'] },
+    { name: 'Tobit', code: 'tob', aliases: ['Tob'] },
+    { name: 'Judith', code: 'jth', aliases: ['Jdt'] },
+    { name: 'Esther', code: 'est', aliases: [] },
+    { name: 'Job', code: 'job', aliases: [] },
+    { name: 'Psalms', code: 'psa', aliases: ['Psalm', 'Ps'] },
+    { name: 'Proverbs', code: 'pro', aliases: ['Prov'] },
+    { name: 'Ecclesiastes', code: 'ecc', aliases: ['Eccl'] },
+    {
+        name: 'Song of Songs',
+        code: 'son',
+        aliases: ['Song of Solomon', 'Canticles'],
+    },
+    { name: 'Wisdom', code: 'wis', aliases: [] },
+    { name: 'Sirach', code: 'sir', aliases: ['Ecclesiasticus'] },
+    { name: 'Isaiah', code: 'isa', aliases: ['Isa'] },
+    { name: 'Jeremiah', code: 'jer', aliases: ['Jer'] },
+    { name: 'Lamentations', code: 'lam', aliases: [] },
+    { name: 'Baruch', code: 'bar', aliases: [] },
+    { name: 'Ezekiel', code: 'eze', aliases: ['Ezek'] },
+    { name: 'Daniel', code: 'dan', aliases: ['Dan'] },
+    { name: 'Hosea', code: 'hos', aliases: [] },
+    { name: 'Joel', code: 'joe', aliases: [] },
+    { name: 'Amos', code: 'amo', aliases: [] },
+    { name: 'Obadiah', code: 'oba', aliases: [] },
+    { name: 'Jonah', code: 'jon', aliases: [] },
+    { name: 'Micah', code: 'mic', aliases: [] },
+    { name: 'Nahum', code: 'nah', aliases: [] },
+    { name: 'Habakkuk', code: 'hab', aliases: [] },
+    { name: 'Zephaniah', code: 'zep', aliases: [] },
+    { name: 'Haggai', code: 'hag', aliases: [] },
+    { name: 'Zechariah', code: 'zec', aliases: [] },
+    { name: 'Malachi', code: 'mal', aliases: [] },
+    { name: '1 Maccabees', code: '1ma', aliases: [] },
+    { name: '2 Maccabees', code: '2ma', aliases: [] },
+    { name: 'Matthew', code: 'mat', aliases: ['Mt', 'Matt'] },
+    { name: 'Mark', code: 'mar', aliases: ['Mk'] },
+    { name: 'Luke', code: 'luk', aliases: ['Lk'] },
+    { name: 'John', code: 'joh', aliases: ['Jn'] },
+    { name: 'Acts', code: 'act', aliases: [] },
+    { name: 'Romans', code: 'rom', aliases: ['Rom'] },
+    { name: '1 Corinthians', code: '1co', aliases: ['1 Cor'] },
+    { name: '2 Corinthians', code: '2co', aliases: ['2 Cor'] },
+    { name: 'Galatians', code: 'gal', aliases: ['Gal'] },
+    { name: 'Ephesians', code: 'eph', aliases: ['Eph'] },
+    { name: 'Philippians', code: 'phi', aliases: ['Phil'] },
+    { name: 'Colossians', code: 'col', aliases: [] },
+    { name: '1 Thessalonians', code: '1th', aliases: ['1 Thess'] },
+    { name: '2 Thessalonians', code: '2th', aliases: ['2 Thess'] },
+    { name: '1 Timothy', code: '1ti', aliases: ['1 Tim'] },
+    { name: '2 Timothy', code: '2ti', aliases: ['2 Tim'] },
+    { name: 'Titus', code: 'tit', aliases: [] },
+    { name: 'Philemon', code: 'phm', aliases: ['Philem'] },
+    { name: 'Hebrews', code: 'heb', aliases: [] },
+    { name: 'James', code: 'jam', aliases: ['Jas'] },
+    { name: '1 Peter', code: '1pe', aliases: ['1 Pet'] },
+    { name: '2 Peter', code: '2pe', aliases: ['2 Pet'] },
+    { name: '1 John', code: '1jo', aliases: ['1 Jn'] },
+    { name: '2 John', code: '2jo', aliases: ['2 Jn'] },
+    { name: '3 John', code: '3jo', aliases: ['3 Jn'] },
+    { name: 'Jude', code: 'jud', aliases: [] },
+    { name: 'Revelation', code: 'rev', aliases: ['Apocalypse'] },
+];

package/dist/esm/client.d.ts

@@ -0,0 +1,18 @@
+import { type ScriptureBookCode } from './books.js';
+import type { ScriptureReference } from './references.js';
+export type AmbryScriptureConfig = {
+    apiKey: string;
+    baseUrl?: string;
+};
+export type ScriptureVerse = {
+    book_code: ScriptureBookCode;
+    chapter: number;
+    verse: number;
+    english_text?: string | null;
+    greek_text?: string | null;
+    latin_text?: string | null;
+};
+export declare function fetchScripture(reference: ScriptureReference, config: AmbryScriptureConfig, fetcher?: typeof fetch): Promise<{
+    verses: ScriptureVerse[];
+    total: number;
+}>;

package/dist/esm/client.js

@@ -0,0 +1,95 @@
+import { scriptureBooks } from './books.js';
+function validateReference(reference) {
+    if (!scriptureBooks.some((book) => book.code === reference.bookCode) ||
+        !Number.isInteger(reference.chapter) ||
+        reference.chapter < 1 ||
+        reference.chapter > 150) {
+        throw new Error('Enter a valid scripture book code and chapter.');
+    }
+    if (reference.firstVerse == null && reference.lastVerse == null)
+        return;
+    if (!Number.isInteger(reference.firstVerse) ||
+        !Number.isInteger(reference.lastVerse) ||
+        reference.firstVerse < 1 ||
+        reference.lastVerse > 176 ||
+        reference.lastVerse < reference.firstVerse) {
+        throw new Error('Enter a valid scripture verse or range.');
+    }
+}
+export async function fetchScripture(reference, config, fetcher = fetch) {
+    validateReference(reference);
+    if (typeof config.apiKey !== 'string' || !config.apiKey.trim())
+        throw new Error('An Ambry API key is required.');
+    const baseUrl = new URL(config.baseUrl ?? 'https://api.ambry.church');
+    if (!['https:', 'http:'].includes(baseUrl.protocol) || baseUrl.username || baseUrl.password) {
+        throw new Error('Use an HTTP(S) Ambry base URL without embedded credentials.');
+    }
+    const verses = [];
+    let total = 0;
+    for (let page = 1; page <= 2; page++) {
+        const url = new URL('api/v1/bible-verses', baseUrl.href.replace(/\/?$/, '/'));
+        url.searchParams.set('book_code', reference.bookCode);
+        url.searchParams.set('chapter', String(reference.chapter));
+        if (reference.firstVerse === reference.lastVerse && reference.firstVerse != null)
+            url.searchParams.set('verse', String(reference.firstVerse));
+        url.searchParams.set('per_page', '100');
+        url.searchParams.set('page', String(page));
+        const response = await fetcher(url, {
+            headers: {
+                Authorization: `Bearer ${config.apiKey}`,
+                Accept: 'application/json',
+            },
+            signal: AbortSignal.timeout(15000),
+            redirect: 'error',
+        });
+        if (!response.ok)
+            throw new Error(`Ambry scripture request failed (HTTP ${response.status}).`);
+        const data = await response.json();
+        const result = data;
+        if (!result ||
+            !result.pagination ||
+            result.pagination.page !== page ||
+            result.pagination.per_page !== 100 ||
+            !Number.isInteger(result.pagination.total) ||
+            result.pagination.total < 0 ||
+            result.pagination.total > 176 ||
+            !Number.isInteger(result.pagination.total_pages) ||
+            result.pagination.total_pages < 0 ||
+            result.pagination.total_pages > 2 ||
+            (result.data != null && !Array.isArray(result.data))) {
+            throw new Error('Ambry returned an invalid scripture response.');
+        }
+        total = result.pagination.total;
+        for (const verse of result.data ?? []) {
+            if (!verse ||
+                verse.book_code !== reference.bookCode ||
+                verse.chapter !== reference.chapter ||
+                !Number.isInteger(verse.verse) ||
+                verse.verse < 1 ||
+                verse.verse > 176 ||
+                ['english_text', 'greek_text', 'latin_text'].some((field) => verse[field] != null && typeof verse[field] !== 'string') ||
+                (reference.firstVerse === reference.lastVerse &&
+                    reference.firstVerse != null &&
+                    verse.verse !== reference.firstVerse)) {
+                throw new Error('Ambry returned an invalid scripture verse.');
+            }
+            if (verses.some((saved) => saved.verse === verse.verse))
+                throw new Error('Ambry returned duplicate scripture verses.');
+            verses.push(verse);
+        }
+        if (page >= result.pagination.total_pages)
+            break;
+    }
+    if (verses.length !== total)
+        throw new Error('Ambry returned an incomplete scripture passage.');
+    const selected = verses
+        .sort((a, b) => a.verse - b.verse)
+        .filter((verse) => reference.firstVerse == null ||
+        (verse.verse >= reference.firstVerse && verse.verse <= reference.lastVerse));
+    if (reference.firstVerse != null &&
+        selected.length &&
+        selected.length !== reference.lastVerse - reference.firstVerse + 1) {
+        throw new Error('Ambry did not return every verse in the requested range.');
+    }
+    return { verses: selected, total: selected.length };
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,2 @@
+export { scriptureBooks, type ScriptureBook, type ScriptureBookCode } from './books.js';
+export { parseScriptureReference, findScriptureReferences, scriptureLanguages, type ScriptureLanguage, type ScriptureReference, type ParseScriptureOptions, type FindScriptureOptions, } from './references.js';

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export { scriptureBooks } from './books.js';
+export { parseScriptureReference, findScriptureReferences, scriptureLanguages, } from './references.js';

package/dist/esm/references.d.ts

@@ -0,0 +1,32 @@
+import { type ScriptureBookCode } from './books.js';
+export type ScriptureLanguage = 'english' | 'greek' | 'latin';
+export type ScriptureReference = {
+    book: string;
+    bookCode: ScriptureBookCode;
+    chapter: number;
+    firstVerse?: number;
+    lastVerse?: number;
+    language?: ScriptureLanguage;
+};
+export type ParseScriptureOptions = {
+    maxVerses?: number;
+};
+export type FindScriptureOptions = ParseScriptureOptions & {
+    maxReferences?: number;
+};
+export declare const scriptureLanguages: {
+    readonly english: {
+        readonly label: "English";
+        readonly field: "english_text";
+    };
+    readonly greek: {
+        readonly label: "Greek";
+        readonly field: "greek_text";
+    };
+    readonly latin: {
+        readonly label: "Latin";
+        readonly field: "latin_text";
+    };
+};
+export declare function parseScriptureReference(input: string, options?: ParseScriptureOptions): ScriptureReference | undefined;
+export declare function findScriptureReferences(content: string, options?: FindScriptureOptions): ScriptureReference[];