codexparser 0.1.52 → 0.1.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexparser",
-  "version": "0.1.52",
+  "version": "0.1.54",
   "description": "This is a Javascript Bible parser and text scanner. It will search through texts and collate all scripture references into an array and parse them into objects, and it will parse passages into objects by book, chapter, verse, and testament. ",
   "main": "index.js",
   "scripts": {

package/src/CodexParser.js

@@ -186,148 +186,119 @@ class CodexParser {
      * @returns {object} An object with the parsed passage.
      */
     parse(reference) {
-        this.scan(reference) // Call scan to populate this.found
+        this.scan(reference) // Populate this.found
 
         this.passages = this.found.map((passage) => {
             const book = this.bookify(passage.book)
-            const testament = this.bible.old.find((bible) => bible === book) ? "old" : "new"
-
-            // Initialize the parsed passage object
+            const testament = this.bible.old.includes(book) ? "old" : "new"
+            const singleChapterBook = this.singleChapterBook.find((b) => Object.keys(b)[0] === book)
             const parsedPassage = {
                 original: passage.book + " " + passage.reference,
                 book: book,
                 chapter: null,
-                verses: [], // Verses stored as an array
-                type: passage.type, // Set type based on reference
+                verses: [],
+                type: passage.type,
                 testament: testament,
                 index: passage.index,
                 version: this._handleVersion(passage.version, testament),
             }
 
-            // Split reference by commas to handle multiple ranges or verses (e.g., "Isaiah 8:22-9:1,5")
-            let parts = passage.reference.split(",")
-
-            // Check for single-chapter books
-            const singleChapterBook = this.singleChapterBook.find((bible) => bible[book])
+            // Split reference into parts (e.g., "2 John 1", "2 John 2", "2 John 1:1-3,5")
+            const parts = passage.reference.split(",")
 
             parts.forEach((part, partIndex) => {
-                part = part.trim() // Clean up spaces
-                const separator = part.includes(":") ? ":" : "."
-
-                if (part.includes("-")) {
-                    // Handle ranges (e.g., "8:22-9:1")
-                    let [start, end] = part.split("-")
-
-                    // Handle the starting part
-                    let [startChapter, startVerse] = start.includes(separator)
-                        ? start.split(separator)
-                        : [parsedPassage.chapter, start] // Default to same chapter if no chapter is provided
-
-                    parsedPassage.chapter = Number(startChapter) // Set the chapter
-
-                    // Multi-chapter verse range logic
-                    if (start.includes(separator) && end.includes(separator)) {
-                        let [endChapter, endVerse] = end.split(separator)
-
-                        parsedPassage.verses = this.chapterVerses[book][startChapter].slice(
-                            this.chapterVerses[book][startChapter].indexOf(Number(startVerse))
-                        )
-
-                        if (Number(endChapter) !== Number(startChapter)) {
-                            const endVerses = this.chapterVerses[book][endChapter].slice(
-                                0,
-                                this.chapterVerses[book][endChapter].indexOf(Number(endVerse)) + 1
-                            )
-                            // Construct ranges for the `to` object
-                            parsedPassage.to = {
-                                book: book,
-                                chapter: Number(endChapter),
-                                verses: [endVerse],
-                            }
+                part = part.trim()
 
-                            parsedPassage.type = "multi_chapter_verse_range"
-                        } else {
-                            parsedPassage.verses.push(`${startVerse}-${endVerse}`)
-                        }
-                    } else {
-                        if (separator !== ":") {
-                            // then this is a chapter_range
-                            let [startChapter, endChapter] = part.split("-")
-                            parsedPassage.chapter = Number(startChapter)
-                            parsedPassage.verses = [
-                                `${this.chapterVerses[book][parsedPassage.chapter][0]}-${
-                                    this.chapterVerses[book][parsedPassage.chapter][
-                                        this.chapterVerses[book][parsedPassage.chapter].length - 1
-                                    ]
-                                }`,
-                            ]
-                            parsedPassage.to = {
-                                book: book,
-                                chapter: Number(endChapter),
-                                verses: [
-                                    `${this.chapterVerses[book][endChapter][0]}-${
-                                        this.chapterVerses[book][endChapter][
-                                            this.chapterVerses[book][endChapter].length - 1
-                                        ]
-                                    }`,
-                                ],
-                            }
-                        } else {
-                            // Handles when verses are present.
-                            parsedPassage.verses = [part.split(separator)[1]]
-                        }
+                if (part.includes(":")) {
+                    // Explicit chapter:verse (e.g., "1:1-3")
+                    const [chapterPart, versePart] = part.split(":")
+                    if (partIndex === 0) {
+                        parsedPassage.chapter = Number(chapterPart) // Set chapter only on first part
                     }
-                } else {
-                    // Handle individual chapter:verse references (e.g., "9:5" in "8:22-9:1,5")
-
-                    let [chapterPart, versePart] = part.includes(separator)
-                        ? part.split(separator)
-                        : [parsedPassage.chapter, part]
 
-                    if (separator.trim() !== ":" && !parsedPassage.chapter) {
-                        if (singleChapterBook) {
+                    if (versePart.includes("-")) {
+                        parsedPassage.verses.push(versePart) // Add range (e.g., "1-3")
+                    } else {
+                        parsedPassage.verses.push(Number(versePart)) // Add single verse
+                    }
+                    parsedPassage.type = versePart.includes("-") ? "chapter_verse_range" : "chapter_verse"
+                } else if (singleChapterBook) {
+                    // Handle single-chapter books
+                    const verseCount = singleChapterBook[book][1].length
+                    if (part === "1" && parts.length === 1 && partIndex === 0) {
+                        // "2 John 1" means the whole chapter
+                        parsedPassage.chapter = 1
+                        parsedPassage.type = "single_chapter"
+                        parsedPassage.verses = [`1-${verseCount}`] // e.g., "1-13"
+                    } else if (part.includes("-")) {
+                        // "2 John 3-5" → "2 John 1:3-5"
+                        parsedPassage.chapter = 1
+                        parsedPassage.verses.push(part) // e.g., "3-5"
+                        parsedPassage.type = "chapter_verse_range"
+                    } else {
+                        // "2 John 2" → "2 John 1:2"
+                        const num = Number(part)
+                        if (num > 1 || (num === 1 && parts.length > 1)) {
                             parsedPassage.chapter = 1
-                            parsedPassage.verses.push(versePart) // Add single verse to array
-                        } else {
-                            parsedPassage.chapter = Number(part)
-                            parsedPassage.verses = [
-                                `${this.chapterVerses[book][parsedPassage.chapter][0]}-${
-                                    this.chapterVerses[book][parsedPassage.chapter][
-                                        this.chapterVerses[book][parsedPassage.chapter].length - 1
-                                    ]
-                                }`,
-                            ]
+                            parsedPassage.verses.push(num) // Treat as verse number
+                            parsedPassage.type = "chapter_verse"
                         }
+                    }
+                } else if (part.includes("-") && !parsedPassage.chapter) {
+                    // Range without chapter for multi-chapter books (e.g., "Isaiah 3-5")
+                    const [start, end] = part.split("-").map(Number)
+                    parsedPassage.chapter = start
+                    parsedPassage.verses = [
+                        `${this.chapterVerses[book][start][0]}-${this.chapterVerses[book][start].slice(-1)[0]}`,
+                    ]
+                    parsedPassage.to = {
+                        book,
+                        chapter: end,
+                        verses: [`${this.chapterVerses[book][end][0]}-${this.chapterVerses[book][end].slice(-1)[0]}`],
+                    }
+                    parsedPassage.type = "chapter_range"
+                } else if (part.includes("-")) {
+                    // Verse range in current chapter (e.g., "8-9" after "40:3-5")
+                    parsedPassage.verses.push(part)
+                    parsedPassage.type = "chapter_verse_range"
+                } else {
+                    // Single number (chapter or verse) for multi-chapter books
+                    if (partIndex === 0 && !parsedPassage.chapter) {
+                        parsedPassage.chapter = Number(part)
+                        parsedPassage.type = "single_chapter"
                     } else {
-                        if (chapterPart) {
-                            if (partIndex === parts.length - 1 && parsedPassage.to) {
-                                // Add additional verses to the last chapter in multi-chapter range
-                                if (!parsedPassage.to.verses) parsedPassage.to.verses = []
-                                parsedPassage.to.verses.push(Number(versePart))
-                            } else {
-                                parsedPassage.chapter = Number(chapterPart)
-                                parsedPassage.verses.push(Number(versePart))
-                            }
-                        }
+                        parsedPassage.verses.push(Number(part))
+                        parsedPassage.type = "comma_separated_verses"
                     }
                 }
-
-                parsedPassage.passages = this.populate(parsedPassage)
-                parsedPassage.scripture = this.scripturize(parsedPassage)
             })
 
-            // Handle range merging in `to` object
-            if (parsedPassage.to && Array.isArray(parsedPassage.to.verses)) {
-                parsedPassage.to.verses = this.mergeRanges(parsedPassage.to.verses)
-            }
-
+            // Populate passages and scripture after processing all parts
+            parsedPassage.passages = this.populate(parsedPassage)
+            parsedPassage.scripture = this.scripturize(parsedPassage)
             parsedPassage.valid = this._isValid(parsedPassage, passage.reference)
 
+            // Handle multi-chapter range if applicable
+            if (
+                parsedPassage.type === "multi_chapter_verse_range" &&
+                parts.some((p) => p.includes(":") && p.split(":")[0] !== String(parsedPassage.chapter))
+            ) {
+                const lastPart = parts[parts.length - 1]
+                const [endChapter, endVerse] = lastPart.split(":")
+                parsedPassage.to = {
+                    book: book,
+                    chapter: Number(endChapter),
+                    verses: endVerse.includes("-") ? [endVerse] : [Number(endVerse)],
+                }
+            } else {
+                delete parsedPassage.to // Remove erroneous 'to' property
+            }
+
             return parsedPassage
         })
 
         this.versification()
-        return this // Return this instance
+        return this
     }
     /**
      * Generates an array of numbers representing a range from start to end, inclusive.
@@ -405,14 +376,6 @@ class CodexParser {
         })
     }
 
-    /**
-     * Populate a Set of passages from entities.start.v to entities.end.v,
-     * and then add any additional verses from the verses array.
-     *
-     * @param {Object} entities - Entities object from the bible-passage-reference-parser
-     * @param {Array} verses - Array of verse numbers to add to the set of passages
-     * @return {Array} Array of passage objects
-     */
     /**
      * Populate all verses from a parsed passage, including all verses in ranges or chapters.
      *
@@ -421,26 +384,40 @@ class CodexParser {
      */
     populate(parsedPassage) {
         const passages = []
-
         const { book, chapter, verses, type, to } = parsedPassage
         const version = parsedPassage.version ? parsedPassage.version.abbreviation : "eng"
         this._setVersion(book, chapter, version) // Set version data if needed
 
+        const singleChapterBook = this.singleChapterBook.find((b) => Object.keys(b)[0] === book)
+
         if (type === "single_chapter") {
-            // Handle entire chapter references
-            if (this.chapterVerses[book] && this.chapterVerses[book][chapter]) {
+            // Handle entire chapter references (e.g., "Isaiah 40" or "2 John 1")
+            if (singleChapterBook) {
+                // Single-chapter book: populate all verses from singleChapterBook
+                const verseCount = singleChapterBook[book][1].length
+                for (let verse = 1; verse <= verseCount; verse++) {
+                    passages.push({ book, chapter: 1, verse })
+                }
+            } else if (this.chapterVerses[book] && this.chapterVerses[book][chapter]) {
+                // Multi-chapter book: populate all verses in the chapter
                 this.chapterVerses[book][chapter].forEach((verse) => {
                     passages.push({ book, chapter: Number(chapter), verse: Number(verse) })
                 })
             }
-        } else if (type === "comma_separated_verses") {
-            // Handle explicitly mentioned verses (e.g., 3:1,3,6)
-
+        } else if (type === "comma_separated_verses" || type === "chapter_verse_range") {
+            // Handle comma-separated verses or single-chapter verse ranges (e.g., "Isaiah 40:3-5,8-9" or "2 John 1:1-3")
             verses.forEach((verse) => {
-                passages.push({ book, chapter: Number(chapter), verse: Number(verse) })
+                if (typeof verse === "string" && verse.includes("-")) {
+                    const [start, end] = verse.split("-").map(Number)
+                    for (let i = start; i <= end; i++) {
+                        passages.push({ book, chapter: Number(chapter), verse: i })
+                    }
+                } else {
+                    passages.push({ book, chapter: Number(chapter), verse: Number(verse) })
+                }
             })
         } else if (type === "chapter_range") {
-            // Handle ranges of chapters (e.g., 3-5)
+            // Handle ranges of chapters (e.g., "Isaiah 3-5")
             for (let currentChapter = chapter; currentChapter <= to.chapter; currentChapter++) {
                 if (this.chapterVerses[book] && this.chapterVerses[book][currentChapter]) {
                     this.chapterVerses[book][currentChapter].forEach((verse) => {
@@ -449,18 +426,17 @@ class CodexParser {
                 }
             }
         } else if (type === "multi_chapter_verse_range") {
-            // Handle multi-chapter verse ranges (e.g., 3:1-5:6)
+            // Handle multi-chapter verse ranges (e.g., "Isaiah 3:1-5:6")
             const startChapter = chapter
-            const startVerse = verses[0]
+            const startVerse = verses[0].includes("-") ? Number(verses[0].split("-")[0]) : Number(verses[0])
             const endChapter = to.chapter
-            const endVerse = to.verses[to.verses.length - 1]
+            const endVerse = to.verses[0].includes("-") ? Number(to.verses[0].split("-")[1]) : Number(to.verses[0])
 
             for (let currentChapter = startChapter; currentChapter <= endChapter; currentChapter++) {
                 const chapterVerses = this.chapterVerses[book][currentChapter]
                 if (!chapterVerses) continue
 
-                // Determine start and end verses for each chapter
-                const chapterStartVerse = currentChapter === startChapter ? startVerse : 1
+                const chapterStartVerse = currentChapter === startChapter ? startVerse : chapterVerses[0]
                 const chapterEndVerse =
                     currentChapter === endChapter ? endVerse : chapterVerses[chapterVerses.length - 1]
 
@@ -468,22 +444,13 @@ class CodexParser {
                     passages.push({ book, chapter: currentChapter, verse })
                 }
             }
-        } else if (type === "chapter_verse" || type === "chapter_verse_range") {
-            // Handle single chapter:verse or chapter:verse ranges (e.g., 3:1 or 3:1-5)
-            if (this.chapterVerses[book] && this.chapterVerses[book][chapter]) {
-                verses.forEach((verse) => {
-                    if (typeof verse === "string" && verse.includes("-")) {
-                        const [start, end] = verse.split("-").map(Number)
-                        for (let i = start; i <= end; i++) {
-                            passages.push({ book, chapter: Number(chapter), verse: i })
-                        }
-                    } else {
-                        passages.push({ book, chapter: Number(chapter), verse: Number(verse) })
-                    }
-                })
-            }
+        } else if (type === "chapter_verse") {
+            // Handle single chapter:verse references (e.g., "2 John 1:1")
+            verses.forEach((verse) => {
+                passages.push({ book, chapter: Number(chapter), verse: Number(verse) })
+            })
         } else if (type === "single_chapter_book_verse_range") {
-            // Handle ranges in single-chapter books (e.g., Jude 5-7)
+            // Handle ranges in single-chapter books (e.g., "Jude 5-7")
             const [startVerse, endVerse] = verses[0].split("-").map(Number)
             for (let i = startVerse; i <= endVerse; i++) {
                 passages.push({ book, chapter: 1, verse: i })
@@ -786,31 +753,35 @@ class CodexParser {
         return orderedToc
     }
 
+    /**
+     * Validates a parsed passage to ensure the chapter and verses exist.
+     *
+     * @param {Object} passage - The parsed passage object to validate.
+     * @param {string} reference - The original reference string for error messaging.
+     * @return {boolean|Object} True if valid, or an error object if invalid.
+     */
     _isValid(passage, reference) {
-        const singleChapterBook = this.singleChapterBook.find((bible) => bible[passage.book])
-        if (!passage.verses) {
-            return {
-                error: true,
-                code: 101,
-                message: {
-                    chapter_exists: false,
-                    content: "Possible invalid chapter: " + reference,
-                },
-            }
-        }
-        if (!singleChapterBook) {
-            if (!this.chapterVerses[passage.book][passage.chapter]) {
+        const singleChapterBook = this.singleChapterBook.find((b) => Object.keys(b)[0] === passage.book)
+
+        // Check if verses exist at all
+        if (!passage.verses || passage.verses.length === 0) {
+            if (passage.type !== "single_chapter") {
                 return {
                     error: true,
-                    code: 102,
+                    code: 101,
                     message: {
                         chapter_exists: false,
-                        content: `Chapter ${passage.chapter} does not exist in ${passage.book}`,
+                        content: "Possible invalid chapter: " + reference,
                     },
                 }
             }
-        } else {
-            if (!singleChapterBook[passage.book][passage.chapter]) {
+        }
+
+        // Handle single-chapter books
+        if (singleChapterBook) {
+            const verseCount = singleChapterBook[passage.book][1].length
+
+            if (passage.chapter !== 1) {
                 return {
                     error: true,
                     code: 103,
@@ -820,19 +791,78 @@ class CodexParser {
                     },
                 }
             }
+
+            if (passage.type === "single_chapter") {
+                // For "2 John 1", validate the full range
+                const [range] = passage.verses // e.g., "1-13"
+                if (range) {
+                    const [start, end] = range.split("-").map(Number)
+                    if (start < 1 || end > verseCount) {
+                        return {
+                            error: true,
+                            code: 104,
+                            message: {
+                                verse_exists: false,
+                                content: `Verse range ${start}-${end} exceeds available verses (1-${verseCount}) in ${passage.book} 1`,
+                            },
+                        }
+                    }
+                }
+                return true // If no specific verses or range matches, it’s valid
+            }
+
+            // For specific verses in single-chapter books (e.g., "2 John 1:1-3")
+            for (let i = 0; i < passage.verses.length; i++) {
+                const verseRange = String(passage.verses[i])
+                let versesToCheck = verseRange.includes("-") ? verseRange.split("-").map(Number) : [Number(verseRange)]
+
+                if (versesToCheck.length === 2) {
+                    const [start, end] = versesToCheck
+                    versesToCheck = Array.from({ length: end - start + 1 }, (_, idx) => start + idx)
+                }
+
+                for (const verse of versesToCheck) {
+                    if (verse < 1 || verse > verseCount) {
+                        return {
+                            error: true,
+                            code: 104,
+                            message: {
+                                verse_exists: false,
+                                content: `Verse number ${verse} does not exist in ${passage.book} 1`,
+                            },
+                        }
+                    }
+                }
+            }
+            return true
+        }
+
+        // Handle multi-chapter books
+        if (!this.chapterVerses[passage.book] || !this.chapterVerses[passage.book][passage.chapter]) {
+            return {
+                error: true,
+                code: 102,
+                message: {
+                    chapter_exists: false,
+                    content: `Chapter ${passage.chapter} does not exist in ${passage.book}`,
+                },
+            }
+        }
+
+        if (passage.type === "single_chapter") {
+            return true // For multi-chapter books, whole chapter is valid if it exists
         }
+
         for (let i = 0; i < passage.verses.length; i++) {
             const passageVerses = String(passage.verses[i])
-            let verses = passageVerses.split("-").map(Number)
+            let verses = passageVerses.includes("-") ? passageVerses.split("-").map(Number) : [Number(passageVerses)]
 
             if (verses.length === 2) {
                 // Expand the range if there are two numbers
                 verses = Array.from({ length: verses[1] - verses[0] + 1 }, (_, index) => verses[0] + index)
             }
 
-            // The verses array now contains all values between the range or remains as a single value
             for (const verse of verses) {
-                // Check if the verse exists in the chapterVerses structure
                 const isValidVerse =
                     this.chapterVerses[passage.book] &&
                     this.chapterVerses[passage.book][passage.chapter] &&
@@ -850,6 +880,7 @@ class CodexParser {
                 }
             }
         }
+
         return true
     }
     _handleVersion(version, testament) {