codexparser 0.1.41 → 0.1.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexparser",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "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

@@ -65,138 +65,110 @@ class CodexParser {
         // Initialize the `found` array to store the results
         this.found = []
 
+        // Preprocess input text: normalize separators while preserving abbreviations
+        let normalizedText = text
+            .replace(/\.(?=\d)/g, ":") // Convert periods before numbers into colons (e.g., 12.15 -> 12:15)
+            .replace(/(\b[A-Za-z]+)\.(?=\s|$)/g, "$1") // Remove periods after abbreviations (e.g., Jd. -> Jd)
+            .replace(/\s+/g, " ") // Normalize multiple spaces to a single space
+
         // Convert Bible book names, abbreviations, and input text to lowercase for case-insensitive matching
         const lowercaseBibleFullNames = fullNames.map((book) => book.toLowerCase())
         const lowercaseBibleAbbreviations = abbreviations.map((abbr) => abbr.toLowerCase())
-        const lowerCaseText = text.toLowerCase()
+        const lowerCaseText = normalizedText.toLowerCase()
 
-        let i = 0 // Index pointer to iterate through the input text
+        let i = 0
 
-        /**
-         * Helper function to check if a character is part of a chapter or verse reference.
-         * Non-word characters (anything not A-Z or a-z) are considered valid.
-         */
         const isValidChapterVerseChar = (char) => /[^A-Za-z]/.test(char)
 
-        /**
-         * Helper function to determine if the text starting at a given index contains
-         * the name of a new Bible book.
-         */
         const isNextBibleBook = (startIndex) => {
             const textAfterCurrentPosition = lowerCaseText.substring(startIndex).trim()
-
-            // Check for full Bible book names
-            for (const book of lowercaseBibleFullNames) {
-                if (textAfterCurrentPosition.startsWith(book)) return true
-            }
-
-            // Check for Bible book abbreviations
-            for (const abbr of lowercaseBibleAbbreviations) {
-                if (textAfterCurrentPosition.startsWith(abbr)) return true
-            }
-
-            return false // No match found
+            return (
+                lowercaseBibleFullNames.some((book) => textAfterCurrentPosition.startsWith(book)) ||
+                lowercaseBibleAbbreviations.some((abbr) => textAfterCurrentPosition.startsWith(abbr))
+            )
         }
 
-        /**
-         * Helper function to detect suffixes like "LXX" or "MT" in the text after a given index.
-         * These suffixes are case-insensitive and indicate the version of the Bible reference.
-         */
         const detectSuffix = (startIndex) => {
-            const suffixMatch = text.substring(startIndex).match(/\b(LXX|MT)\b/i)
+            const suffixMatch = normalizedText.substring(startIndex).match(/\b(LXX|MT)\b/i)
             return suffixMatch ? suffixMatch[0].toUpperCase() : null
         }
 
-        // Iterate through the input text to detect and process Bible references
         while (i < lowerCaseText.length) {
-            let foundBook = null // Placeholder for the detected book name
-            let foundIndex = -1 // Index in the text where the book name starts
-            let matchedLength = 0 // Length of the matched book name or abbreviation
+            let foundBook = null
+            let foundIndex = -1
+            let matchedLength = 0
 
-            // Search for full Bible book names in the text
             for (let j = 0; j < lowercaseBibleFullNames.length; j++) {
                 const book = lowercaseBibleFullNames[j]
                 if (lowerCaseText.startsWith(book, i) && book.length > matchedLength) {
-                    foundBook = fullNames[j] // Store the original book name (case-sensitive)
+                    foundBook = fullNames[j]
                     foundIndex = i
-                    matchedLength = book.length // Update the match length
+                    matchedLength = book.length
                 }
             }
 
-            // If no full book name is found, search for abbreviations
             if (!foundBook) {
                 for (let k = 0; k < lowercaseBibleAbbreviations.length; k++) {
                     const abbreviation = lowercaseBibleAbbreviations[k]
-                    if (lowerCaseText.startsWith(abbreviation, i)) {
-                        foundBook = abbreviations[k]
+                    if (lowerCaseText.startsWith(abbreviation, i) && abbreviation.length > matchedLength) {
+                        foundBook = this.abbreviations[abbreviations[k]]
                         foundIndex = i
                         matchedLength = abbreviation.length
                     }
                 }
             }
 
-            // If a Bible book is found
             if (foundBook) {
-                i += matchedLength // Move the index pointer forward by the length of the book name
-                let chapterVerse = "" // Placeholder for chapter and verse data
-                const references = [] // Array to store multiple chapter/verse references for the same book
-
-                // Extract chapter and verse references
-                while (i < text.length && isValidChapterVerseChar(text[i])) {
-                    if (isNextBibleBook(i)) break // Stop if a new Bible book is detected
-
-                    // Handle semicolon-separated references (indicates a new reference)
-                    if (text[i] === ";") {
-                        const formattedReference = chapterVerse
-                            .trim()
-                            .replace(/\./g, ":")
-                            .replace(/[^a-zA-Z0-9]+$/, "")
+                i += matchedLength
+                let chapterVerse = ""
+                const references = []
+
+                while (i < normalizedText.length && isValidChapterVerseChar(normalizedText[i])) {
+                    if (isNextBibleBook(i)) break
+
+                    if (normalizedText[i] === ";") {
+                        const formattedReference = chapterVerse.trim().replace(/[^a-zA-Z0-9]+$/, "")
                         if (formattedReference) references.push(formattedReference)
-                        chapterVerse = "" // Reset for the next reference
+                        chapterVerse = ""
                         i++
                         continue
                     }
 
-                    chapterVerse += text[i]
+                    chapterVerse += normalizedText[i]
                     i++
                 }
 
-                // Process the last detected chapter/verse reference
                 if (chapterVerse.trim().length > 0) {
-                    const formattedReference = chapterVerse
-                        .trim()
-                        .replace(/\./g, ":")
-                        .replace(/[^a-zA-Z0-9]+$/, "")
+                    const formattedReference = chapterVerse.trim().replace(/[^a-zA-Z0-9]+$/, "")
                     if (formattedReference) references.push(formattedReference)
                 }
 
-                // Detect any suffix (e.g., "LXX" or "MT") after the chapter/verse reference
                 const suffix = detectSuffix(i)
 
-                // Add each reference as a separate object to the `found` array with type recognition
                 references.forEach((ref) => {
                     let type
-
                     if (ref.includes(":")) {
                         if (ref.includes("-")) {
                             const [start, end] = ref.split("-")
                             const startParts = start.split(":")
                             const endParts = end.split(":")
 
-                            if (startParts.length > 1 && endParts.length > 1 && startParts[0] !== endParts[0]) {
-                                type = "multi_chapter_verse_range" // Example: "8:23-9:1"
-                            } else {
-                                type = "chapter_verse_range" // Example: "8:23-25"
-                            }
+                            // Determine type based on the chapter (startParts[0] and endParts[0])
+                            type =
+                                startParts.length > 1 &&
+                                endParts.length > 1 &&
+                                startParts[0].trim() !== endParts[0].trim()
+                                    ? "multi_chapter_verse_range" // Chapters differ
+                                    : "chapter_verse_range" // Same chapter
                         } else if (ref.includes(",")) {
-                            type = "comma_separated_verses" // Example: "8:23,24"
+                            type = "comma_separated_verses"
                         } else {
-                            type = "chapter_verse" // Example: "8:23"
+                            type = "chapter_verse"
                         }
                     } else if (ref.includes("-")) {
-                        type = "chapter_range" // Example: "8-9"
+                        type = "chapter_range"
                     } else {
-                        type = "single_chapter" // Example: "8"
+                        type = "single_chapter"
                     }
 
                     this.found.push({
@@ -208,11 +180,11 @@ class CodexParser {
                     })
                 })
             } else {
-                i++ // Move to the next character if no book is found
+                i++
             }
         }
 
-        return this // Return the current instance for method chaining
+        return this
     }
 
     bibleVersion(version) {
@@ -232,93 +204,148 @@ class CodexParser {
      * @returns {object} An object with the parsed passage.
      */
     parse(reference) {
-        this.scan(reference)
+        this.scan(reference) // Call scan to populate this.found
 
         this.passages = this.found.map((passage) => {
             const book = this.bookify(passage.book)
-            const testament = this.bible.old.includes(book) ? "old" : "new"
-
+            const testament = this.bible.old.find((bible) => bible === book) ? "old" : "new"
+            // Initialize the parsed passage object
             const parsedPassage = {
-                original: `${passage.book} ${passage.reference}`,
-                book,
+                original: passage.book + " " + passage.reference,
+                book: book,
                 chapter: null,
-                verses: [],
-                type: passage.type,
-                testament,
+                verses: [], // Verse stored as an array
+                type: passage.type, // Set type based on reference
+                testament: testament,
                 index: passage.index,
                 version: this._handleVersion(passage.version, testament),
             }
-            const parts = passage.reference.split(",")
-            const isSingleChapter = this.singleChapterBook.some((singleChapterBook) => singleChapterBook[book])
+
+            // Split reference by commas to handle multiple ranges or verses (e.g., "Ge 27:27-29,39-41")
+            let parts = passage.reference.split(",")
+
+            // Check for single chapter books
+            const singleChapterBook = this.singleChapterBook.find((bible) => bible[book])
 
             parts.forEach((part) => {
-                part = part.trim()
+                part = part.trim() // Clean up spaces
+                // Detect whether it uses ":" or "." for chapter:verse separation
                 const separator = part.includes(":") ? ":" : "."
 
                 if (part.includes("-")) {
-                    if (!isSingleChapter) {
-                        if (part.includes(":")) {
-                            let [start, end] = part.split("-")
-                            const [startChapter, startVerse] = start.includes(separator)
-                                ? start.split(separator).map(Number)
-                                : [parsedPassage.chapter, Number(start)]
-                            const [endChapter, endVerse] = end.includes(separator)
-                                ? end.split(separator).map(Number)
-                                : [startChapter, Number(end)]
-
-                            parsedPassage.chapter = startChapter
-
-                            if (startChapter !== endChapter) {
+                    // Handle ranges (e.g., "27:27-29" or "39-41")
+
+                    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
+                    // Checks to see if we are in a multi chapter verse range, if so, include only relevant verses from the this.chapterVerse to
+                    // the end of the chapter.
+                    if (start.includes(separator) && end.includes(separator)) {
+                        // TODO: Need to update versification and version here.
+                        this._setVersion(book, startChapter, passage.version)
+                        parsedPassage.verses = this.chapterVerses[book][startChapter].slice(
+                            this.chapterVerses[book][startChapter].indexOf(Number(startVerse))
+                        )
+                    }
+
+                    // Handle chapter ranges (e.g., "27:27-29") and multi-chapter ranges (e.g., "Ex 2:1-3:4")
+                    if (end.includes(separator)) {
+                        let [endChapter, endVerse] = end.split(separator)
+                        if (Number(endChapter) !== Number(startChapter)) {
+                            // Cross-chapter range, set 'to' property
+                            parsedPassage.to = {
+                                book: book,
+                                chapter: Number(endChapter), // End chapter
+                            }
+
+                            if (endVerse > 1) {
+                                parsedPassage.to.verses = this.chapterVerses[book][Number(endChapter)].slice(
+                                    0,
+                                    this.chapterVerses[book][Number(endChapter)].indexOf(Number(endVerse)) + 1
+                                )
+                            } else {
+                                parsedPassage.to.verses = [endVerse]
+                            }
+                            parsedPassage.type =
+                                endChapter !== startChapter ? "multi_chapter_verse_range" : "chapter_verse_range" // Set type to chapter range
+                        } else {
+                            // Same-chapter range, just add to the verse array
+                            parsedPassage.verses.push(`${startVerse}-${endVerse}`)
+                        }
+                    } else {
+                        // Single-chapter range (e.g., "27:27-29" or "39-41")
+                        if (!singleChapterBook) {
+                            if (!startChapter) {
+                                // Then we have a chapter range with no verses
+                                parsedPassage.chapter = Number(start)
+                                parsedPassage.verses = this.chapterVerses[book][start]
                                 parsedPassage.to = {
-                                    book,
-                                    chapter: endChapter,
-                                    verses: [endVerse],
+                                    book: book,
+                                    chapter: Number(end),
+                                    verses: this.chapterVerses[book][end],
                                 }
-                                parsedPassage.verses.push(startVerse)
                             } else {
-                                parsedPassage.verses.push(...this._generateRange(startVerse, endVerse))
+                                //
+                                parsedPassage.verses.push(`${startVerse}-${end}`)
                             }
                         } else {
-                            const [start, end] = part.split("-")
-                            parsedPassage.chapter = Number(start)
-                            parsedPassage.to = {
-                                book,
-                                chapter: Number(end),
-                                verses: [],
-                            }
+                            parsedPassage.chapter = 1
+                            parsedPassage.verses.push(`${startVerse}-${end}`)
                         }
-                    } else {
-                        part = part.replace(/\d+:/gim, "")
-                        const [singleChapterStartVerse, singleChapterEndVerse] = part.split("-")
-                        parsedPassage.chapter = 1
-                        parsedPassage.verses = [`${singleChapterStartVerse}-${singleChapterEndVerse}`]
-                        parsedPassage.type = "single_chapter_book_verse_range"
                     }
-                } else if (part.includes(separator)) {
-                    const [chapterPart, versePart] = part.split(separator).map(Number)
-                    parsedPassage.chapter = chapterPart
-                    if (versePart) parsedPassage.verses.push(versePart)
                 } else {
-                    if (!isSingleChapter) {
-                        const number = Number(part)
-                        if (!parsedPassage.verses.length) {
-                            parsedPassage.chapter = number
+                    // Handle individual chapter:verse references (e.g., "27:27")
+
+                    let [chapterPart, versePart] = part.includes(separator)
+                        ? part.split(separator)
+                        : [parsedPassage.chapter, part]
+                    if (singleChapterBook) {
+                        if (!chapterPart) {
+                            parsedPassage.chapter = 1
+                            parsedPassage.verses.push(versePart) // Add single verse to array
+                        } else {
+                            parsedPassage.chapter = Number(chapterPart)
+                            parsedPassage.verses.push(versePart) // Add single verse to array
                         }
-                        parsedPassage.verses.push(Number(part))
                     } else {
-                        parsedPassage.chapter = 1
-                        parsedPassage.verses.push(Number(part))
+                        // Need to check if chapterPart is undefined
+                        // If it's undefined, then versePart actually is the chapter and we need to populate the
+                        // verses from this.chapterVerses
+
+                        if (chapterPart) {
+                            parsedPassage.chapter = Number(chapterPart)
+                            parsedPassage.verses.push(versePart) // Add single verse to array
+                        } else {
+                            parsedPassage.chapter = Number(versePart)
+                            if (!this.chapterVerses[book][parsedPassage.chapter]) {
+                                parsedPassage.valid = this._isValid(parsedPassage, passage.reference)
+                            } else {
+                                parsedPassage.verses = [
+                                    this.chapterVerses[book][parsedPassage.chapter][0] +
+                                        "-" +
+                                        this.chapterVerses[book][parsedPassage.chapter][
+                                            this.chapterVerses[book][parsedPassage.chapter].length - 1
+                                        ],
+                                ]
+                                parsedPassage.type = "single_chapter"
+                            }
+                        }
                     }
                 }
+                parsedPassage.passages = this.populate(parsedPassage)
+                parsedPassage.scripture = this.scripturize(parsedPassage)
             })
 
-            parsedPassage.passages = this.populate(parsedPassage)
-            parsedPassage.scripture = this.scripturize(parsedPassage)
             parsedPassage.valid = this._isValid(parsedPassage, passage.reference)
+
             return parsedPassage
         })
         this.versification()
-        return this
+        return this // Return this instance
     }
     /**
      * Generates an array of numbers representing a range from start to end, inclusive.
@@ -331,17 +358,17 @@ class CodexParser {
         return range
     }
 
-    _searchVersificationDifferences(passage) {
-        const { book, chapter, version } = passage
-
+    _searchVersificationDifferences(book, chapter, version) {
+        version = version.toLowerCase()
+        if (!this.chapterVerses[book][chapter]) return
         // Loop through each key-value pair in the dictionary
         for (const [key, value] of Object.entries(this.versificationDifferences[book])) {
             // Check if the key starts with the desired chapter
-            if (value[version.abbreviation].startsWith(`${chapter}:`)) {
+            if (value[version].startsWith(`${chapter}:`)) {
                 // Ensure the version exists in the value object
-                if (value[version.abbreviation]) {
+                if (value[version]) {
                     // Extract the verse number from the value
-                    const verse = value[version.abbreviation].split(":")[1]
+                    const verse = value[version].split(":")[1]
                     this.chapterVerses[book][chapter].push(Number(verse))
                 }
             }
@@ -350,18 +377,17 @@ class CodexParser {
         return this.chapterVerses // Return the array of verses
     }
 
-    _setVersion(passage) {
-        this.version = passage.version ? passage.version.abbreviation : "eng"
+    _setVersion(book, chapter, version) {
+        this.version = version ? version : "eng"
 
         if (this.version !== "eng") {
-            this._searchVersificationDifferences(passage)
+            this._searchVersificationDifferences(book, chapter, version)
         }
     }
 
     versification() {
         this.passages.forEach((passage) => {
             const hasVersification = this.versificationDifferences[passage.book]
-
             passage.passages.forEach((subPassage) => {
                 // Apply general versification differences
                 if (hasVersification) {
@@ -412,79 +438,56 @@ class CodexParser {
      */
     populate(parsedPassage) {
         const passages = []
-        const { book, chapter, verses, type } = parsedPassage
-        this._setVersion(parsedPassage)
+        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
+
         if (type === "single_chapter") {
-            // Handle single chapter references
+            // Handle entire chapter references
             if (this.chapterVerses[book] && this.chapterVerses[book][chapter]) {
                 this.chapterVerses[book][chapter].forEach((verse) => {
                     passages.push({ book, chapter: Number(chapter), verse: Number(verse) })
                 })
             }
         } else if (type === "comma_separated_verses") {
-            // Handle only the explicitly mentioned verses
-            if (verses && this.chapterVerses[book] && this.chapterVerses[book][chapter]) {
+            // Handle explicitly mentioned verses (e.g., 3:1,3,6)
+            if (this.chapterVerses[book] && this.chapterVerses[book][chapter]) {
                 verses.forEach((verse) => {
                     passages.push({ book, chapter: Number(chapter), verse: Number(verse) })
                 })
             }
         } else if (type === "chapter_range") {
-            const { to } = parsedPassage
-
-            for (let i = chapter; i <= to.chapter; i++) {
-                const verses = this.chapterVerses[book][i]
-                for (let j = verses[0]; j < verses.length; j++) {
-                    passages.push({
-                        book,
-                        chapter: i,
-                        verse: j,
+            // Handle ranges of chapters (e.g., 3-5)
+            for (let currentChapter = chapter; currentChapter <= to.chapter; currentChapter++) {
+                if (this.chapterVerses[book] && this.chapterVerses[book][currentChapter]) {
+                    this.chapterVerses[book][currentChapter].forEach((verse) => {
+                        passages.push({ book, chapter: Number(currentChapter), verse: Number(verse) })
                     })
                 }
             }
         } else if (type === "multi_chapter_verse_range") {
-            const { to } = parsedPassage
-            // Create an array of reference objects for the start and end of the range
-            const refs = [
-                {
-                    chapter: Number(parsedPassage.chapter),
-                    verse: Number(parsedPassage.verses[0]),
-                },
-                {
-                    chapter: Number(to.chapter),
-                    verse: Number(to.verses[to.verses.length - 1]),
-                },
-            ]
-
-            const startChapter = refs[0].chapter
-            const startVerse = refs[0].verse
-            const endChapter = refs[refs.length - 1].chapter
-            const endVerse = refs[refs.length - 1].verse
-
-            // Loop through the range of chapters
-            for (let chapter = startChapter; chapter <= endChapter; chapter++) {
-                // Determine the starting verse for the current chapter
-                const chapterStartVerse = chapter === startChapter ? startVerse : 1
-                // Determine the ending verse for the current chapter
-                const chapterEndVerse = chapter === endChapter ? endVerse : this.chapterVerses[book][chapter].length
-
-                // Get the array of verses for the current chapter
-                const verses = this.chapterVerses[book][chapter].slice(chapterStartVerse - 1, chapterEndVerse)
-
-                // Loop through the verses in the current chapter
-                for (let j = 0; j < verses.length; j++) {
-                    const currentVerse = chapterStartVerse + j
-
-                    // Add the verse to the passages array
-                    passages.push({
-                        book,
-                        chapter,
-                        verse: currentVerse,
-                    })
+            // Handle multi-chapter verse ranges (e.g., 3:1-5:6)
+            const startChapter = chapter
+            const startVerse = verses[0]
+            const endChapter = to.chapter
+            const endVerse = to.verses[to.verses.length - 1]
+
+            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 chapterEndVerse =
+                    currentChapter === endChapter ? endVerse : chapterVerses[chapterVerses.length - 1]
+
+                for (let verse = chapterStartVerse; verse <= chapterEndVerse; verse++) {
+                    passages.push({ book, chapter: currentChapter, verse })
                 }
             }
         } else if (type === "chapter_verse" || type === "chapter_verse_range") {
-            // Handle chapter:verse or chapter:verse-range references
-            if (verses && this.chapterVerses[book] && this.chapterVerses[book][chapter]) {
+            // 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)
@@ -496,6 +499,12 @@ class CodexParser {
                     }
                 })
             }
+        } else if (type === "single_chapter_book_verse_range") {
+            // 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 })
+            }
         }
 
         return passages
@@ -557,64 +566,60 @@ class CodexParser {
      * @return {object} The object with the human-readable name, chapter and verses and a hash.
      */
     scripturize(passage) {
-        const { book, chapter, passages, to } = passage
-
-        // Extract verses from the passages array
-        const verses = passages.map((p) => ({ chapter: p.chapter, verse: p.verse }))
-        let formattedVerses = ""
-
-        if (to && to.chapter && to.chapter !== chapter) {
-            // Handle multi-chapter range
-            const startChapter = chapter
-            const startVerses = verses.filter((v) => v.chapter === startChapter).map((v) => v.verse)
-
-            const endChapter = to.chapter
-            const endVerses = verses.filter((v) => v.chapter === endChapter).map((v) => v.verse)
-
-            const startFormatted =
-                startVerses.length > 1 ? `${startVerses[0]}-${startVerses[startVerses.length - 1]}` : startVerses[0]
-
-            const endFormatted =
-                endVerses.length > 1 ? `${endVerses[0]}-${endVerses[endVerses.length - 1]}` : endVerses[0]
-
-            formattedVerses = `${startChapter}:${startFormatted}-${endChapter}:${endFormatted}`
-        } else {
-            // Handle single-chapter range
-            const startVerses = verses.map((v) => v.verse)
-
-            if (startVerses.length === 1) {
-                formattedVerses = startVerses[0].toString()
-            } else {
-                // Group consecutive verses into ranges
-                let ranges = []
-                let tempRange = [startVerses[0]]
-
-                for (let i = 1; i < startVerses.length; i++) {
-                    if (startVerses[i] === startVerses[i - 1] + 1) {
-                        tempRange.push(startVerses[i])
-                    } else {
-                        ranges.push(tempRange)
-                        tempRange = [startVerses[i]]
-                    }
-                }
-                ranges.push(tempRange)
+        // Helper to format a single chapter:verse combination
+        const formatChapterVerse = (chapter, verseStart, verseEnd = null) => {
+            if (!chapter) return ""
+            if (!verseStart) return `${chapter}`
+            return verseEnd ? `${chapter}:${verseStart}-${verseEnd}` : `${chapter}:${verseStart}`
+        }
 
-                formattedVerses = ranges
-                    .map((range) => (range.length > 1 ? `${range[0]}-${range[range.length - 1]}` : range[0]))
-                    .join(",")
+        // Initialize combined passage
+        let combined = `${passage.book}`
+
+        if (passage.type === "multi_chapter_verse_range") {
+            // Multi-chapter verse range handling: first verse of first chapter to last verse of last chapter
+            if (passage.to) {
+                combined += ` ${formatChapterVerse(passage.chapter, passage.verses[0])}` // Start chapter:verse
+                combined += `-${formatChapterVerse(
+                    passage.to.chapter,
+                    passage.to.verses[passage.to.verses.length - 1]
+                )}` // End chapter:last verse
             }
-
-            formattedVerses = `${chapter}:${formattedVerses}`
+        } else if (passage.type === "chapter_verse_range") {
+            // Single-chapter verse range
+            combined += ` ${formatChapterVerse(
+                passage.chapter,
+                passage.verses[0],
+                passage.verses[passage.verses.length - 1]
+            )}`
+        } else if (passage.type === "comma_separated_verses") {
+            // Comma-separated verses
+            combined += ` ${passage.chapter}:${passage.verses.join(",")}`
+        } else if (passage.type === "chapter_range") {
+            // Chapter range
+            combined += ` ${passage.chapter}:${passage.verses[0]}-${passage.to.chapter}:${
+                passage.to.verses[passage.to.verses.length - 1]
+            }`
+        } else {
+            // Single chapter or single verse
+            combined += ` ${formatChapterVerse(passage.chapter, passage.verses[0])}`
         }
 
-        // Format the final passage
-        const full = `${book} ${formattedVerses}`.trim()
-        const hash = full.toLowerCase().replace(/ /g, "_").replace(/:/g, ".").replace(/-/g, ".").replace(/,/g, ".")
+        // Generate chapter:verse for current and "to" objects
+        const cv = passage.to
+            ? `${formatChapterVerse(passage.chapter, passage.verses[0])}-${formatChapterVerse(
+                  passage.to.chapter,
+                  passage.to.verses[passage.to.verses.length - 1]
+              )}`
+            : formatChapterVerse(passage.chapter, passage.verses[0])
+
+        // Generate a hash for the passage
+        const hash = `${passage.book.toLowerCase()}_${cv.replace(/:/g, "_").replace(/-/g, "_")}`
 
         return {
-            passage: full,
-            cv: formattedVerses,
-            hash,
+            passage: combined, // Reconstructed passage
+            cv: cv, // Chapter:verse range
+            hash: hash, // Unique hash
         }
     }
 
@@ -628,13 +633,14 @@ class CodexParser {
      * @return {object} The combined passage object.
      */
     combine(passages) {
-        // Only check if passages are from the same book
-        const noDuplicates = [...new Set(passages.map((p) => p.book))]
-        if (noDuplicates.length > 1) {
+        // Only check if passages are from the same book)
+        const sameBook = [...new Set(passages.map((p) => p.book))]
+        if (sameBook.length > 1) {
             throw new Error("Passages are not from the same book.")
         }
 
         const newPassages = []
+
         passages.forEach((passageSet) => {
             passageSet.passages.forEach((passage) => {
                 if (passage.versification) {
@@ -646,6 +652,7 @@ class CodexParser {
         })
 
         const noDuplicates2 = [...new Set(newPassages)]
+
         const parsed = this.parse(noDuplicates2.join(" // ")).getPassages()
         return this.join(parsed)
     }
@@ -658,87 +665,100 @@ class CodexParser {
      * @return {object} The combined passage object.
      */
     join(passages) {
-        const newObject = { ...passages[0] } // Start with the first passage
+        if (!passages || passages.length === 0) {
+            throw new Error("No passages provided to join.")
+        }
 
-        const chapters = {} // Store verses by chapters
-        const uniquePassages = new Set() // Track unique passages to prevent duplicates
+        // Ensure all passages are from the same book
+        const uniqueBooks = [...new Set(passages.map((p) => p.book))]
+        if (uniqueBooks.length > 1) {
+            throw new Error("Passages must be from the same book to join.")
+        }
 
-        // Add initial passages to the unique set to avoid duplication
-        newObject.passages.forEach((p) => {
-            const passageKey = `${p.book}-${p.chapter}-${p.verse}`
-            uniquePassages.add(passageKey)
-        })
+        // Start with the base object
+        const combined = {
+            ...passages[0],
+            verses: [],
+            passages: [],
+            to: null,
+            scripture: {},
+            type: null,
+        }
 
-        // Iterate through all the passages and group verses by chapter
-        passages.forEach((passage) => {
-            if (!chapters[passage.chapter]) {
-                chapters[passage.chapter] = new Set() // Use Set to avoid duplicates
-            }
+        const chapterVerses = {}
+        let firstChapter = null
+        let lastChapter = null
 
-            // Add verses to their corresponding chapter
+        // Collect all verses and passages, grouped by chapter
+        passages.forEach((passage) => {
             passage.passages.forEach((p) => {
-                chapters[p.chapter].add(p.verse)
-
-                // Create a unique key for each passage (book-chapter-verse)
-                const passageKey = `${p.book}-${p.chapter}-${p.verse}`
-
-                // Add to the passages array if it hasn't been added yet
-                if (!uniquePassages.has(passageKey)) {
-                    newObject.passages.push(p) // Add the passage
-                    uniquePassages.add(passageKey) // Mark it as added
+                if (!chapterVerses[p.chapter]) {
+                    chapterVerses[p.chapter] = new Set()
                 }
+                chapterVerses[p.chapter].add(p.verse)
+                combined.passages.push(p) // Add individual passage
             })
-        })
 
-        // Sort the newObject.passages array by chapter first, then by verse
-        newObject.passages.sort((a, b) => {
-            if (a.chapter !== b.chapter) {
-                return a.chapter - b.chapter // Sort by chapter
+            // Track first and last chapters
+            const chapters = passage.passages.map((p) => p.chapter)
+            if (!firstChapter || Math.min(...chapters) < firstChapter) {
+                firstChapter = Math.min(...chapters)
+            }
+            if (!lastChapter || Math.max(...chapters) > lastChapter) {
+                lastChapter = Math.max(...chapters)
             }
-            return a.verse - b.verse // Sort by verse within the same chapter
         })
 
-        // Prepare to build the final result
+        // Ensure unique and sorted passages
+        combined.passages = Array.from(new Set(combined.passages.map(JSON.stringify))).map(JSON.parse)
+
+        // Process chapter and verse data
         const chapterStrings = []
-        let firstChapter = null
-        let lastChapter = null
+        const sortedChapters = Object.keys(chapterVerses)
+            .map(Number)
+            .sort((a, b) => a - b)
 
-        for (const chapter in chapters) {
-            const verses = Array.from(chapters[chapter]).sort((a, b) => a - b)
-            const mergedVerses = this.mergeRanges(verses) // Merge adjacent verses into ranges
+        sortedChapters.forEach((chapter) => {
+            const verses = Array.from(chapterVerses[chapter]).sort((a, b) => a - b)
+            const mergedVerses = this.mergeRanges(verses)
             chapterStrings.push(`${chapter}:${mergedVerses.join(",")}`)
-
-            // Track the first and last chapters for the 'to' key
-            if (!firstChapter) firstChapter = Number(chapter) // Ensure chapter is a number
-            lastChapter = Number(chapter) // Always update to the current chapter as a number
-
-            // Update the newObject.verses with the merged ranges for the current chapter
-            if (Number(chapter) === firstChapter) {
-                newObject.verses = mergedVerses
+            if (chapter === firstChapter) {
+                combined.verses = mergedVerses // First chapter's verses
             }
-        }
-
-        // Build the final combined object with `to` key for multi-chapter passages
-        newObject.original = `${newObject.book} ${firstChapter}:${newObject.verses.join(",")}`
+        })
 
+        // Handle multi-chapter ranges
         if (firstChapter !== lastChapter) {
-            newObject.to = {
-                book: newObject.book,
+            combined.type = "multi_chapter_verse_range"
+            combined.to = {
+                book: combined.book,
                 chapter: lastChapter,
-                verses: this.mergeRanges(Array.from(chapters[lastChapter])), // Ensure merged range
+                verses: this.mergeRanges(Array.from(chapterVerses[lastChapter])),
+            }
+            combined.original = `${combined.book} ${firstChapter}:${combined.verses.join(
+                ","
+            )}-${lastChapter}:${combined.to.verses.join(",")}`
+        } else {
+            // Single-chapter range or comma-separated
+            if (combined.verses.length > 1) {
+                combined.type = "chapter_verse_range"
+            } else {
+                combined.type = "chapter_verse"
             }
+            combined.original = `${combined.book} ${firstChapter}:${combined.verses.join(",")}`
         }
 
-        // Build the scripture string with combined chapters (without spaces after commas)
-        const chapterString = chapterStrings.join(",") // No space after comma
-        newObject.scripture = {
-            passage: `${newObject.book} ${chapterString}`,
+        // Build the scripture property
+        const chapterString = chapterStrings.join(",")
+        combined.scripture = {
+            passage: `${combined.book} ${chapterString}`,
             cv: chapterString,
-            hash: `${newObject.book.toLowerCase()}_${chapterString.replace(/:/g, ".").replace(/,/g, ".")}`,
+            hash: `${combined.book.toLowerCase()}_${chapterString.replace(/:/g, ".").replace(/,/g, ".")}`,
         }
 
-        return newObject
+        return combined
     }
+
     mergeRanges(verses) {
         const sortedVerses = [...new Set(verses)].sort((a, b) => a - b)
         const merged = []
@@ -749,11 +769,9 @@ class CodexParser {
             if (sortedVerses[i] === end + 1) {
                 end = sortedVerses[i]
             } else {
-                // Push the current range if it's more than 2 consecutive numbers, otherwise separate by commas
+                // Push range or single verse
                 if (start === end) {
                     merged.push(`${start}`)
-                } else if (end === start + 1) {
-                    merged.push(`${start},${end}`)
                 } else {
                     merged.push(`${start}-${end}`)
                 }
@@ -762,11 +780,9 @@ class CodexParser {
             }
         }
 
-        // Push the final range or pair
+        // Push the final range or single verse
         if (start === end) {
             merged.push(`${start}`)
-        } else if (end === start + 1) {
-            merged.push(`${start},${end}`)
         } else {
             merged.push(`${start}-${end}`)
         }
@@ -848,6 +864,22 @@ class CodexParser {
                 }
             }
         }
+        for (let i = 0; i < passage.verses.length; i++) {
+            let verse = passage.verses[i]
+            const searchForVerse = this.chapterVerses[passage.book][passage.chapter].find(
+                (v) => Number(v) === Number(verse)
+            )
+            if (!searchForVerse) {
+                return {
+                    error: true,
+                    code: 104,
+                    message: {
+                        verse_exists: false,
+                        content: `Verse number ${verse} does not exist in ${passage.book} ${passage.chapter}`,
+                    },
+                }
+            }
+        }
         return true
     }
     _handleVersion(version, testament) {