codexparser 0.1.97 → 0.2.0

package/src/core/ScriptureScanner.js

@@ -0,0 +1,235 @@
+/**
+ * ScriptureScanner.js
+ * Handles scanning text for scripture references
+ */
+
+const bible = require("../data/bible")
+const abbreviations = require("../format/abbr")
+
+/**
+ * Scanner for finding scripture references in text
+ */
+class ScriptureScanner {
+    #bible
+    #abbreviations
+    #config
+
+    /**
+     * @param {Object} config - Configuration options
+     */
+    constructor(config = {}) {
+        this.#bible = bible
+        this.#abbreviations = abbreviations
+        this.#config = config
+    }
+
+    /**
+     * Scans text for scripture references
+     * @param {string} text - The text to scan
+     * @returns {Array} Array of found references
+     */
+    scan(text) {
+        const fullNames = [...this.#bible.old, ...this.#bible.new]
+        const abbreviationKeys = Object.keys(this.#abbreviations)
+        const found = []
+
+        // Minimal normalization: fix periods before numbers, remove trailing periods
+        const normalizedText = text.replace(/\.(?=\d)/g, ":").replace(/(\b[A-Za-z]+)\.(?=\s|$)/g, "$1")
+
+        const lowercaseBibleFullNames = fullNames.map((book) => book.toLowerCase())
+        const lowercaseBibleAbbreviations = abbreviationKeys.map((abbr) => abbr.toLowerCase())
+        const lowerCaseText = normalizedText.toLowerCase()
+
+        let i = 0
+
+        while (i < lowerCaseText.length) {
+            let foundBook = null
+            let bookStartIndex = -1
+            let matchedLength = 0
+
+            // Skip whitespace and special characters before checking for book
+            while (i < lowerCaseText.length && /[\s—-]/.test(lowerCaseText[i])) {
+                i++
+            }
+            if (i >= lowerCaseText.length) break
+
+            // Check for full book names
+            for (let j = 0; j < lowercaseBibleFullNames.length; j++) {
+                const book = lowercaseBibleFullNames[j]
+                if (lowerCaseText.startsWith(book, i) && book.length > matchedLength) {
+                    foundBook = fullNames[j]
+                    bookStartIndex = i
+                    matchedLength = book.length
+                }
+            }
+
+            // Check for abbreviations
+            if (!foundBook) {
+                for (let k = 0; k < lowercaseBibleAbbreviations.length; k++) {
+                    const abbreviation = lowercaseBibleAbbreviations[k]
+                    if (lowerCaseText.startsWith(abbreviation, i) && abbreviation.length > matchedLength) {
+                        foundBook = this.#abbreviations[abbreviationKeys[k]]
+                        bookStartIndex = i
+                        matchedLength = abbreviation.length
+                    }
+                }
+            }
+
+            if (foundBook) {
+                i += matchedLength
+                let chapterVerse = ""
+                const references = []
+                let refStartIndex = bookStartIndex
+                let originalRefStartIndex = bookStartIndex
+
+                while (i < normalizedText.length && this.#isValidChapterVerseChar(normalizedText[i])) {
+                    if (this.#isNextBibleBook(i, lowerCaseText, lowercaseBibleFullNames, lowercaseBibleAbbreviations)) {
+                        break
+                    }
+                    if (normalizedText[i] === ";") {
+                        const formattedReference = chapterVerse.trim()
+                        if (formattedReference) {
+                            const refEndIndex = i
+                            references.push({
+                                ref: formattedReference,
+                                start: refStartIndex,
+                                end: refEndIndex,
+                            })
+                        }
+                        chapterVerse = ""
+                        refStartIndex = i + 1
+                        const semicolonIndex = text.indexOf(";", originalRefStartIndex)
+                        originalRefStartIndex = semicolonIndex !== -1 ? semicolonIndex + 1 : refStartIndex
+                        i++
+                        continue
+                    }
+                    chapterVerse += normalizedText[i]
+                    i++
+                }
+
+                if (chapterVerse.trim().length > 0) {
+                    const formattedReference = chapterVerse.trim()
+                    if (formattedReference) {
+                        const refEndIndex = i
+                        references.push({
+                            ref: formattedReference,
+                            start: refStartIndex,
+                            end: refEndIndex,
+                        })
+                    }
+                }
+
+                // Align indices with original text
+                const originalBookText = text.slice(bookStartIndex, bookStartIndex + matchedLength)
+                const originalBookStartIndex =
+                    text.indexOf(originalBookText, bookStartIndex) !== -1
+                        ? text.indexOf(originalBookText, bookStartIndex)
+                        : bookStartIndex
+
+                references.forEach(({ ref, start, end }) => {
+                    const type = this.#determineReferenceType(ref)
+                    const fullRefText = `${originalBookText} ${ref.replace(":", ".")}`
+                    const suffixData = this.#detectSuffix(normalizedText, end)
+                    const suffix = suffixData ? suffixData.suffix : null
+                    let refEndIndex = end
+
+                    if (suffixData) {
+                        refEndIndex += suffixData.length
+                        i += suffixData.length
+                    }
+
+                    // Map to original text
+                    let originalStartIndex =
+                        text.indexOf(fullRefText, originalRefStartIndex) !== -1
+                            ? text.indexOf(fullRefText, originalRefStartIndex)
+                            : originalBookStartIndex
+
+                    let originalEndIndex = originalStartIndex + fullRefText.length
+                    let originalText = text.slice(originalStartIndex, originalEndIndex)
+
+                    // Adjust for suffix in original text
+                    if (suffixData) {
+                        originalEndIndex += suffixData.length
+                        originalText = text.slice(originalStartIndex, originalEndIndex)
+                    }
+
+                    // Trim trailing whitespace from originalText
+                    while (originalEndIndex > originalStartIndex && /[\s]/.test(text[originalEndIndex - 1])) {
+                        originalEndIndex--
+                        originalText = text.slice(originalStartIndex, originalEndIndex)
+                    }
+
+                    found.push({
+                        book: foundBook,
+                        reference: ref,
+                        startIndex: originalStartIndex,
+                        endIndex: originalEndIndex,
+                        version: suffix || null,
+                        type,
+                        originalText: originalText,
+                    })
+                })
+            } else {
+                i++
+            }
+        }
+
+        return found
+    }
+
+    /**
+     * Checks if character is valid for chapter/verse references
+     * @private
+     */
+    #isValidChapterVerseChar(char) {
+        return /[\d:,\-;\s]/.test(char)
+    }
+
+    /**
+     * Checks if the next position starts another Bible book
+     * @private
+     */
+    #isNextBibleBook(startIndex, lowerCaseText, lowercaseBibleFullNames, lowercaseBibleAbbreviations) {
+        const textAfterCurrentPosition = lowerCaseText.substring(startIndex).trim()
+        return (
+            lowercaseBibleFullNames.some((book) => textAfterCurrentPosition.startsWith(book)) ||
+            lowercaseBibleAbbreviations.some((abbr) => textAfterCurrentPosition.startsWith(abbr))
+        )
+    }
+
+    /**
+     * Detects version suffix (LXX, MT)
+     * @private
+     */
+    #detectSuffix(text, startIndex) {
+        const suffixMatch = text.substring(startIndex).match(/\b(LXX|MT)\b/i)
+        return suffixMatch ? { suffix: suffixMatch[0].toUpperCase(), length: suffixMatch[0].length } : null
+    }
+
+    /**
+     * Determines the type of scripture reference
+     * @private
+     */
+    #determineReferenceType(ref) {
+        if (ref.includes(":")) {
+            if (ref.includes("-")) {
+                const [start, end] = ref.split("-")
+                const startParts = start.split(":")
+                const endParts = end.split(":")
+                return startParts.length > 1 && endParts.length > 1 && startParts[0].trim() !== endParts[0].trim()
+                    ? "multi_chapter_verse_range"
+                    : "chapter_verse_range"
+            } else if (ref.includes(",")) {
+                return "comma_separated_verses"
+            } else {
+                return "chapter_verse"
+            }
+        } else if (ref.includes("-")) {
+            return "chapter_range"
+        } else {
+            return "single_chapter"
+        }
+    }
+}
+
+module.exports = ScriptureScanner

package/src/core/VersificationHandler.js

@@ -0,0 +1,143 @@
+/**
+ * VersificationHandler.js
+ * Handles versification differences between Bible versions
+ */
+
+const versified = require("../data/versified")
+const PassageUtils = require("../utils/PassageUtils")
+
+/**
+ * Handles versification differences
+ */
+class VersificationHandler {
+    #versificationDifferences
+    #chapterVerses
+
+    constructor() {
+        this.#versificationDifferences = versified
+        // We need to make a copy to avoid mutating the original
+        this.#chapterVerses = {}
+    }
+
+    /**
+     * Searches for versification differences for a book and chapter
+     * @param {string} book - The book name
+     * @param {number} chapter - The chapter number
+     * @param {string} version - The Bible version
+     * @returns {Object|undefined} Updated chapter verses or undefined
+     */
+    searchVersificationDifferences(book, chapter, version) {
+        version = version.toLowerCase()
+
+        // Handle single-chapter book "Obadiah"
+        if (book === "Obadiah") {
+            const singleChapterBook = PassageUtils.SINGLE_CHAPTER_BOOKS.find((b) => Object.keys(b)[0] === "Obadiah")
+            if (!singleChapterBook || !singleChapterBook[book][chapter]) {
+                return // No data for Obadiah or chapter
+            }
+            if (!this.#versificationDifferences[book]) {
+                return // No versification differences for Obadiah
+            }
+
+            // Process versification differences
+            for (const [key, value] of Object.entries(this.#versificationDifferences[book])) {
+                if (value[version]?.startsWith(`${chapter}:`)) {
+                    if (value[version]) {
+                        const verse = value[version].split(":")[1]
+                        singleChapterBook[book][chapter].push(Number(verse))
+                    }
+                }
+            }
+            singleChapterBook[book][chapter] = Array.from(new Set(singleChapterBook[book][chapter]))
+            return singleChapterBook[book]
+        }
+
+        // Handle all other books using chapterVerses
+        const chapterVerses = PassageUtils.getChapterVerses(book, chapter)
+        if (!chapterVerses.length) {
+            return
+        }
+        if (!this.#versificationDifferences[book]) {
+            return
+        }
+
+        // Create a mutable copy
+        if (!this.#chapterVerses[book]) {
+            this.#chapterVerses[book] = {}
+        }
+        if (!this.#chapterVerses[book][chapter]) {
+            this.#chapterVerses[book][chapter] = [...chapterVerses]
+        }
+
+        for (const [key, value] of Object.entries(this.#versificationDifferences[book])) {
+            if (value[version]?.startsWith(`${chapter}:`)) {
+                if (value[version]) {
+                    const verse = value[version].split(":")[1]
+                    this.#chapterVerses[book][chapter].push(Number(verse))
+                }
+            }
+        }
+
+        this.#chapterVerses[book][chapter] = Array.from(new Set(this.#chapterVerses[book][chapter]))
+        return this.#chapterVerses
+    }
+
+    /**
+     * Applies versification differences to parsed passages
+     * @param {Array} passages - Array of passage objects
+     * @returns {Array} Updated passages with versification info
+     */
+    applyVersification(passages) {
+        passages.forEach((passage) => {
+            const hasVersification = this.#versificationDifferences[passage.book]
+
+            passage.passages.forEach((subPassage) => {
+                if (hasVersification) {
+                    const key = `${subPassage.chapter}:${subPassage.verse}`
+                    if (this.#versificationDifferences[passage.book][key]) {
+                        subPassage.versification = this.#versificationDifferences[passage.book][key]
+                    }
+                }
+
+                if (passage.version) {
+                    const versionAbbreviation = passage.version.abbreviation
+                    const versionType =
+                        versionAbbreviation === "lxx" ? "lxx" : versionAbbreviation === "mt" ? "mt" : null
+
+                    if (versionType) {
+                        const versionReference = `${subPassage.chapter}:${subPassage.verse}`
+                        for (const versification in this.#versificationDifferences[passage.book]) {
+                            if (
+                                this.#versificationDifferences[passage.book][versification][versionType] ===
+                                versionReference
+                            ) {
+                                subPassage.versification = this.#versificationDifferences[passage.book][versification]
+                                break
+                            }
+                        }
+                    }
+                }
+            })
+        })
+
+        return passages
+    }
+
+    /**
+     * Gets versification for a specific passage
+     * @param {string} book - Book name
+     * @param {number} chapter - Chapter number
+     * @param {number} verse - Verse number
+     * @returns {Object|null} Versification object or null
+     */
+    getVersification(book, chapter, verse) {
+        if (!this.#versificationDifferences[book]) {
+            return null
+        }
+
+        const key = `${chapter}:${verse}`
+        return this.#versificationDifferences[book][key] || null
+    }
+}
+
+module.exports = VersificationHandler

package/src/core/VersionHandler.js

@@ -0,0 +1,77 @@
+/**
+ * VersionHandler.js
+ * Handles Bible version management and conversions
+ */
+
+/**
+ * Handles Bible version operations
+ */
+class VersionHandler {
+    static VERSIONS = {
+        ENG: { name: "English", value: "ENG", abbreviation: "eng" },
+        LXX: { name: "Septuagint", value: "LXX", abbreviation: "lxx" },
+        MT: { name: "Masoretic Text", value: "MT", abbreviation: "mt" },
+        BHS: { name: "Masoretic Text", value: "MT", abbreviation: "mt" }, // BHS is alias for MT
+    }
+
+    /**
+     * Normalizes version string
+     * @param {string} version - Version string
+     * @returns {string} Normalized version
+     */
+    static normalizeVersion(version) {
+        if (!version) return "eng"
+        const lowerVersion = version.toLowerCase()
+        return lowerVersion === "bhs" ? "mt" : lowerVersion
+    }
+
+    /**
+     * Gets version object for a given version and testament
+     * @param {string} version - Version abbreviation
+     * @param {string} testament - Testament (old/new)
+     * @returns {Object} Version object
+     */
+    static getVersion(version, testament) {
+        const effectiveVersion = version || "eng"
+        const lowerVersion = effectiveVersion.toLowerCase()
+
+        if (lowerVersion === "lxx" && testament === "old") {
+            return VersionHandler.VERSIONS.LXX
+        }
+        if ((lowerVersion === "mt" || lowerVersion === "bhs") && testament === "old") {
+            return VersionHandler.VERSIONS.MT
+        }
+        return VersionHandler.VERSIONS.ENG
+    }
+
+    /**
+     * Validates version string
+     * @param {string} version - Version to validate
+     * @returns {boolean} True if valid
+     */
+    static isValidVersion(version) {
+        const normalized = VersionHandler.normalizeVersion(version)
+        return ["eng", "lxx", "mt"].includes(normalized)
+    }
+
+    /**
+     * Gets version object from abbreviation
+     * @param {string} abbr - Version abbreviation
+     * @returns {Object} Version object
+     */
+    static getVersionObject(abbr) {
+        const normalized = VersionHandler.normalizeVersion(abbr)
+
+        switch (normalized) {
+            case "lxx":
+                return VersionHandler.VERSIONS.LXX
+            case "mt":
+                return VersionHandler.VERSIONS.MT
+            case "eng":
+            default:
+                return VersionHandler.VERSIONS.ENG
+        }
+    }
+}
+
+module.exports = VersionHandler

package/src/data/toc.js

@@ -0,0 +1,7 @@
+const fs = require("fs")
+const path = require("path")
+
+const biblePath = path.join(__dirname, "../../bibles/updated_kjv.json")
+const bible = JSON.parse(fs.readFileSync(biblePath, "utf8"))
+
+module.exports.bible = bible

package/src/format/osis.js

@@ -0,0 +1,210 @@
+/**
+ * osis.js
+ * OSIS reference formatter and book code mapping (text + numeric)
+ */
+
+const bible = require("../data/bible")
+
+const OSIS_BOOKS = {
+    // Old Testament
+    Genesis: "Gen",
+    Exodus: "Exod",
+    Leviticus: "Lev",
+    Numbers: "Num",
+    Deuteronomy: "Deut",
+    Joshua: "Josh",
+    Judges: "Judg",
+    Ruth: "Ruth",
+    "1 Samuel": "1Sam",
+    "2 Samuel": "2Sam",
+    "1 Kings": "1Kgs",
+    "2 Kings": "2Kgs",
+    "1 Chronicles": "1Chr",
+    "2 Chronicles": "2Chr",
+    Ezra: "Ezra",
+    Nehemiah: "Neh",
+    Esther: "Esth",
+    Job: "Job",
+    Psalms: "Ps",
+    Psalm: "Ps",
+    Proverbs: "Prov",
+    Ecclesiastes: "Eccl",
+    "Song of Solomon": "Song",
+    "Song of Songs": "Song",
+    Isaiah: "Isa",
+    Jeremiah: "Jer",
+    Lamentations: "Lam",
+    Ezekiel: "Ezek",
+    Daniel: "Dan",
+    Hosea: "Hos",
+    Joel: "Joel",
+    Amos: "Amos",
+    Obadiah: "Obad",
+    Jonah: "Jonah",
+    Micah: "Mic",
+    Nahum: "Nah",
+    Habakkuk: "Hab",
+    Zephaniah: "Zeph",
+    Haggai: "Hag",
+    Zechariah: "Zech",
+    Malachi: "Mal",
+
+    // New Testament
+    Matthew: "Matt",
+    Mark: "Mark",
+    Luke: "Luke",
+    John: "John",
+    Acts: "Acts",
+    Romans: "Rom",
+    "1 Corinthians": "1Cor",
+    "2 Corinthians": "2Cor",
+    Galatians: "Gal",
+    Ephesians: "Eph",
+    Philippians: "Phil",
+    Colossians: "Col",
+    "1 Thessalonians": "1Thess",
+    "2 Thessalonians": "2Thess",
+    "1 Timothy": "1Tim",
+    "2 Timothy": "2Tim",
+    Titus: "Titus",
+    Philemon: "Phlm",
+    Hebrews: "Heb",
+    James: "Jas",
+    "1 Peter": "1Pet",
+    "2 Peter": "2Pet",
+    "1 John": "1John",
+    "2 John": "2John",
+    "3 John": "3John",
+    Jude: "Jude",
+    Revelation: "Rev",
+}
+
+function getOsisBook(book) {
+    return OSIS_BOOKS[book] || book.replace(/\s+/g, "")
+}
+
+// Build canonical OSIS order (unique, Old + New) using bible.js and OSIS names
+const CANONICAL_OSIS_ORDER = (() => {
+    const order = []
+    const seen = new Set()
+    const pushIfNew = (name) => {
+        const osis = getOsisBook(name)
+        if (!seen.has(osis)) {
+            seen.add(osis)
+            order.push(osis)
+        }
+    }
+    ;[...bible.old, ...bible.new].forEach((name) => pushIfNew(name))
+    return order
+})()
+
+function getCanonicalBookNumber(book) {
+    const osis = getOsisBook(book)
+    const idx = CANONICAL_OSIS_ORDER.indexOf(osis)
+    return idx >= 0 ? idx + 1 : null
+}
+
+/**
+ * Converts a book/chapter/verse into the pythonbible-style integer verse id
+ * Scheme: bookNumber * 1_000_000 + chapter * 1_000 + verse
+ * Example: John 3:16 (book 43) => 43_003_016 => 43003016
+ */
+function toVerseId(book, chapter, verse) {
+    const bnum = getCanonicalBookNumber(book)
+    const ch = Number(chapter)
+    const vs = Number(verse)
+    if (bnum == null || Number.isNaN(ch) || Number.isNaN(vs)) return null
+    return bnum * 1_000_000 + ch * 1_000 + vs
+}
+
+/**
+ * Formats a passage object into an OSIS reference string
+ * - Single verse: Book.Ch.V
+ * - Verse range: Book.Ch.V1-Book.Ch.Vn
+ * - Multi-chapter range: Book.Ch1.V1-Book.Ch2.Vn
+ * - Multiple verses: Book.Ch.V1,Book.Ch.V2
+ * - Sequences across chapters: Book.Ch1.V1;Book.Ch2.V2
+ * @param {Object} passage
+ * @returns {string}
+ */
+function formatOsis(passage) {
+    const book = getOsisBook(passage.book)
+    const chapter = Number(passage.chapter)
+    const verses = passage.verses || []
+
+    const isRange = passage.to && (passage.type === "multi_chapter_verse_range" || passage.type === "chapter_range")
+    if (isRange) {
+        const startVerse =
+            verses[0] && String(verses[0]).includes("-")
+                ? Number(String(verses[0]).split("-")[0])
+                : Number(verses[0]) || 1
+        const endChapter = Number(passage.to.chapter)
+        const endFirst = passage.to.verses?.[0] || "1"
+        const endVerse = String(endFirst).includes("-") ? Number(String(endFirst).split("-")[1]) : Number(endFirst) || 1
+        return `${book}.${chapter}.${startVerse}-${book}.${endChapter}.${endVerse}`
+    }
+
+    // No explicit range: build from verse list at same chapter
+    const parts = []
+    for (const v of verses) {
+        if (String(v).includes("-")) {
+            const [s, e] = String(v).split("-").map(Number)
+            parts.push(`${book}.${chapter}.${s}-${book}.${chapter}.${e}`)
+        } else {
+            const num = Number(v)
+            if (!isNaN(num) && num > 0) {
+                parts.push(`${book}.${chapter}.${num}`)
+            }
+        }
+    }
+    return parts.join(",")
+}
+
+/**
+ * Formats a passage object into an OSIS numeric reference string
+ * - Single verse: B.Ch.V (B = canonical book number 1..66)
+ * - Verse range (same chapter): B.Ch.V1-B.Ch.Vn
+ * - Multi-chapter range: B.Ch1.V1-B.Ch2.Vn
+ * - Multiple verses: B.Ch.V1,B.Ch.V2
+ * - Sequences across chapters: B.Ch1.V1;B.Ch2.V2
+ * @param {Object} passage
+ * @returns {string}
+ */
+function formatOsisNumeric(passage) {
+    const chapter = Number(passage.chapter)
+    const verses = passage.verses || []
+
+    if (Number.isNaN(chapter)) return ""
+
+    const isRange = passage.to && (passage.type === "multi_chapter_verse_range" || passage.type === "chapter_range")
+    if (isRange) {
+        const startVerse =
+            verses[0] && String(verses[0]).includes("-")
+                ? Number(String(verses[0]).split("-")[0])
+                : Number(verses[0]) || 1
+        const endChapter = Number(passage.to.chapter)
+        const endFirst = passage.to.verses?.[0] || "1"
+        const endVerse = String(endFirst).includes("-") ? Number(String(endFirst).split("-")[1]) : Number(endFirst) || 1
+        const startId = toVerseId(passage.book, chapter, startVerse)
+        const endId = toVerseId(passage.book, endChapter, endVerse)
+        return startId != null && endId != null ? `${startId}-${endId}` : ""
+    }
+
+    const parts = []
+    for (const v of verses) {
+        if (String(v).includes("-")) {
+            const [s, e] = String(v).split("-").map(Number)
+            const startId = toVerseId(passage.book, chapter, s)
+            const endId = toVerseId(passage.book, chapter, e)
+            if (startId != null && endId != null) {
+                parts.push(`${startId}-${endId}`)
+            }
+        } else {
+            const num = Number(v)
+            const id = toVerseId(passage.book, chapter, num)
+            if (id != null) parts.push(String(id))
+        }
+    }
+    return parts.join(",")
+}
+module.exports = { formatOsis, getOsisBook, formatOsisNumeric, getCanonicalBookNumber, toVerseId }

package/src/index.js

@@ -0,0 +1,12 @@
+// Public barrel for consumers
+const CodexParser = require("./core/CodexParser")
+const { formatOsis, formatOsisNumeric, toVerseId } = require("./format/osis")
+const PassageUtils = require("./utils/PassageUtils")
+
+module.exports = {
+    CodexParser,
+    formatOsis,
+    formatOsisNumeric,
+    toVerseId,
+    PassageUtils,
+}