codexparser 0.1.42 → 0.1.44

package/package.json

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

@@ -147,16 +147,19 @@ class CodexParser {
 
                 references.forEach((ref) => {
                     let type
-
                     if (ref.includes(":")) {
                         if (ref.includes("-")) {
                             const [start, end] = ref.split("-")
                             const startParts = start.split(":")
                             const endParts = end.split(":")
+
+                            // 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"
-                                    : "chapter_verse_range"
+                                    ? "multi_chapter_verse_range" // Chapters differ
+                                    : "chapter_verse_range" // Same chapter
                         } else if (ref.includes(",")) {
                             type = "comma_separated_verses"
                         } else {
@@ -206,136 +209,103 @@ class CodexParser {
         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 parsedPassage = {
                 original: passage.book + " " + passage.reference,
                 book: book,
                 chapter: null,
-                verses: [], // Verse stored as an array
+                verses: [], // Verses stored as an array
                 type: passage.type, // Set type based on reference
                 testament: testament,
                 index: passage.index,
                 version: this._handleVersion(passage.version, testament),
             }
 
-            // Split reference by commas to handle multiple ranges or verses (e.g., "Ge 27:27-29,39-41")
+            // 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
+            // Check for single-chapter books
             const singleChapterBook = this.singleChapterBook.find((bible) => bible[book])
 
-            parts.forEach((part) => {
+            parts.forEach((part, partIndex) => {
                 part = part.trim() // Clean up spaces
-                // Detect whether it uses ":" or "." for chapter:verse separation
                 const separator = part.includes(":") ? ":" : "."
 
                 if (part.includes("-")) {
-                    // Handle ranges (e.g., "27:27-29" or "39-41")
-
+                    // 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
-                    // 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.
+
+                    // 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))
                         )
-                    }
 
-                    // Handle same-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
+                            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), // End chapter
-                            }
-                            if (endVerse > 1) {
-                                parsedPassage.to.verses = this.chapterVerses[book][Number(endChapter)].slice(
-                                    0,
-                                    this.chapterVerses[book][Number(endChapter)].indexOf(Number(endVerse)) + 1
-                                )
+                                chapter: Number(endChapter),
+                                verses: [`${1}-${endVerse}`, ...endVerses.filter((v) => v > endVerse)],
                             }
-                            parsedPassage.type =
-                                endChapter !== startChapter ? "multi_chapter_verse_range" : "chapter_verse_range" // Set type to chapter range
+
+                            parsedPassage.type = "multi_chapter_verse_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: book,
-                                    chapter: Number(end),
-                                    verses: this.chapterVerses[book][end],
-                                }
-                            } else {
-                                //
-                                parsedPassage.verses.push(`${startVerse}-${end}`)
-                            }
-                        } else {
-                            parsedPassage.chapter = 1
-                            parsedPassage.verses.push(`${startVerse}-${end}`)
-                        }
                     }
                 } else {
-                    // Handle individual chapter:verse references (e.g., "27:27")
-
+                    // 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 (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.chapter = 1
+                        parsedPassage.verses.push(versePart) // Add single verse to array
                     } else {
-                        // 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)
+                            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.verses = [
-                                    this.chapterVerses[book][parsedPassage.chapter][0] +
-                                        "-" +
-                                        this.chapterVerses[book][parsedPassage.chapter][
-                                            this.chapterVerses[book][parsedPassage.chapter].length - 1
-                                        ],
-                                ]
-                                parsedPassage.type = "single_chapter"
+                                parsedPassage.chapter = Number(chapterPart)
+                                parsedPassage.verses.push(Number(versePart))
                             }
                         }
                     }
                 }
+
                 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)
+            }
+
             parsedPassage.valid = this._isValid(parsedPassage, passage.reference)
 
             return parsedPassage
         })
+
         this.versification()
         return this // Return this instance
     }
@@ -350,18 +320,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))
                 }
             }
@@ -370,11 +339,11 @@ 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)
         }
     }
 
@@ -432,8 +401,8 @@ class CodexParser {
     populate(parsedPassage) {
         const passages = []
         const { book, chapter, verses, type, to } = parsedPassage
-
-        this._setVersion(parsedPassage) // Set version data if needed
+        const version = parsedPassage.version ? parsedPassage.version.abbreviation : "eng"
+        this._setVersion(book, chapter, version) // Set version data if needed
 
         if (type === "single_chapter") {
             // Handle entire chapter references
@@ -460,7 +429,6 @@ class CodexParser {
             }
         } else if (type === "multi_chapter_verse_range") {
             // Handle multi-chapter verse ranges (e.g., 3:1-5:6)
-
             const startChapter = chapter
             const startVerse = verses[0]
             const endChapter = to.chapter
@@ -560,60 +528,63 @@ class CodexParser {
      * @return {object} The object with the human-readable name, chapter and verses and a hash.
      */
     scripturize(passage) {
-        // 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}`
+        // Helper function to format a single chapter:verse combination
+        const formatChapterVerse = (chapter, verses) => {
+            if (!chapter || !verses || verses.length === 0) return ""
+            if (verses.length === 1) {
+                return `${chapter}:${verses[0]}`
+            }
+
+            // Check if verses are continuous (e.g., [1, 2, 3, 4, 5] -> "1-5")
+            const isRange = verses.every((v, i, arr) => i === 0 || v === arr[i - 1] + 1)
+
+            if (isRange) {
+                return `${chapter}:${verses[0]}-${verses[verses.length - 1]}`
+            }
+
+            // Comma-separated (e.g., [1, 3, 5] -> "1,3,5")
+            return `${chapter}:${verses.join(",")}`
         }
 
-        // Initialize combined passage
+        // Start constructing the passage string
         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
-            }
+        if (passage.type === "multi_chapter_verse_range" && passage.to) {
+            // Multi-chapter verse range
+            combined += ` ${formatChapterVerse(passage.chapter, passage.verses)}-${formatChapterVerse(
+                passage.to.chapter,
+                passage.to.verses
+            )}`
         } else if (passage.type === "chapter_verse_range") {
             // Single-chapter verse range
-            combined += ` ${formatChapterVerse(
-                passage.chapter,
-                passage.verses[0],
-                passage.verses[passage.verses.length - 1]
-            )}`
+            combined += ` ${formatChapterVerse(passage.chapter, passage.verses)}`
         } else if (passage.type === "comma_separated_verses") {
             // Comma-separated verses
-            combined += ` ${passage.chapter}:${passage.verses.join(",")}`
-        } else if (passage.type === "chapter_range") {
+            combined += ` ${formatChapterVerse(passage.chapter, passage.verses)}`
+        } else if (passage.type === "chapter_range" && passage.to) {
             // Chapter range
-            combined += ` ${passage.chapter}:${passage.verses[0]}-${passage.to.chapter}:${
-                passage.to.verses[passage.to.verses.length - 1]
-            }`
+            combined += ` ${passage.chapter}-${passage.to.chapter}`
         } else {
             // Single chapter or single verse
-            combined += ` ${formatChapterVerse(passage.chapter, passage.verses[0])}`
+            combined += ` ${formatChapterVerse(passage.chapter, passage.verses)}`
         }
 
-        // Generate chapter:verse for current and "to" objects
+        // Generate the chapter:verse (cv) string
         const cv = passage.to
-            ? `${formatChapterVerse(passage.chapter, passage.verses[0])}-${formatChapterVerse(
+            ? `${formatChapterVerse(passage.chapter, passage.verses)}-${formatChapterVerse(
                   passage.to.chapter,
-                  passage.to.verses[passage.to.verses.length - 1]
+                  passage.to.verses
               )}`
-            : formatChapterVerse(passage.chapter, passage.verses[0])
+            : formatChapterVerse(passage.chapter, passage.verses)
 
-        // Generate a hash for the passage
-        const hash = `${passage.book.toLowerCase()}_${cv.replace(/:/g, "_").replace(/-/g, "_")}`
+        // Generate the hash
+        const hash = `${passage.book.toLowerCase()}_${cv.replace(/:/g, ".").replace(/-/g, ".")}`
 
+        // Return the final scripture object
         return {
-            passage: combined, // Reconstructed passage
-            cv: cv, // Chapter:verse range
-            hash: hash, // Unique hash
+            passage: combined,
+            cv: cv,
+            hash: hash,
         }
     }
 
@@ -627,29 +598,96 @@ class CodexParser {
      * @return {object} The combined passage object.
      */
     combine(passages) {
-        // 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.")
+        if (!passages || passages.length === 0) {
+            throw new Error("No passages provided to combine.")
+        }
+
+        // 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 combine.")
         }
 
-        const newPassages = []
+        // Initialize combined passage object
+        const combined = {
+            ...passages[0],
+            verses: [],
+            passages: [],
+            to: null,
+            type: null,
+        }
 
-        passages.forEach((passageSet) => {
-            passageSet.passages.forEach((passage) => {
-                if (passage.versification) {
-                    newPassages.push(passage.book + " " + passage.versification[this.version])
-                } else {
-                    newPassages.push(passage.book + " " + passage.chapter + ":" + passage.verse)
+        const chapterVerses = {}
+        let firstChapter = null
+        let lastChapter = null
+
+        // Collect all verses grouped by chapter
+        passages.forEach((passage) => {
+            passage.passages.forEach((p) => {
+                if (!chapterVerses[p.chapter]) {
+                    chapterVerses[p.chapter] = new Set()
                 }
+                chapterVerses[p.chapter].add(p.verse)
+                combined.passages.push(p) // Add individual passage
             })
+
+            // 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)
+            }
         })
 
-        const noDuplicates2 = [...new Set(newPassages)]
+        // Ensure unique and sorted passages
+        combined.passages = Array.from(new Set(combined.passages.map(JSON.stringify))).map(JSON.parse)
 
-        const parsed = this.parse(noDuplicates2.join(" // ")).getPassages()
+        // Process chapter and verse data
+        const sortedChapters = Object.keys(chapterVerses)
+            .map(Number)
+            .sort((a, b) => a - b)
+
+        const originalParts = []
+        sortedChapters.forEach((chapter, index) => {
+            const verses = Array.from(chapterVerses[chapter]).sort((a, b) => a - b)
+            if (chapter === firstChapter) {
+                combined.verses = verses // First chapter's verses
+            }
+            if (chapter === lastChapter) {
+                combined.to = {
+                    book: combined.book,
+                    chapter,
+                    verses,
+                }
+            }
+            originalParts.push(`${chapter}:${verses.join(",")}`)
+        })
 
-        return this.join(parsed)
+        // Ensure `to` is properly set for multi-chapter ranges
+        if (firstChapter !== lastChapter) {
+            const lastChapterVerses = Array.from(chapterVerses[lastChapter]).sort((a, b) => a - b)
+            combined.to = {
+                book: combined.book,
+                chapter: lastChapter,
+                verses: lastChapterVerses,
+            }
+        }
+
+        // Determine the passage type
+        if (firstChapter !== lastChapter) {
+            combined.type = "multi_chapter_verse_range"
+        } else if (combined.verses.length > 1) {
+            combined.type = "chapter_verse_range"
+        } else {
+            combined.type = "chapter_verse"
+        }
+
+        // Build the `original` field
+        combined.original = `${combined.book} ${originalParts.join("-")}`
+
+        return this.parse(combined.original).getPassages().first()
     }
 
     /**
@@ -660,86 +698,100 @@ class CodexParser {
      * @return {object} The combined passage object.
      */
     join(passages) {
-        const newObject = { ...passages[0] } // Start with the first passage
-
-        const chapters = {} // Store verses by chapters
-        const uniquePassages = new Set() // Track unique passages to prevent duplicates
-        // 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)
-        })
+        if (!passages || passages.length === 0) {
+            throw new Error("No passages provided to join.")
+        }
 
-        // 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
-            }
+        // 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 verses to their corresponding chapter
-            passage.passages.forEach((p) => {
-                chapters[p.chapter].add(p.verse)
+        // Start with the base object
+        const combined = {
+            ...passages[0],
+            verses: [],
+            passages: [],
+            to: null,
+            scripture: {},
+            type: null,
+        }
 
-                // Create a unique key for each passage (book-chapter-verse)
-                const passageKey = `${p.book}-${p.chapter}-${p.verse}`
+        const chapterVerses = {}
+        let firstChapter = null
+        let lastChapter = null
 
-                // 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
+        // Collect all verses and passages, grouped by chapter
+        passages.forEach((passage) => {
+            passage.passages.forEach((p) => {
+                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 = []
@@ -750,11 +802,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}`)
                 }
@@ -763,11 +813,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}`)
         }
@@ -849,6 +897,35 @@ class CodexParser {
                 }
             }
         }
+        for (let i = 0; i < passage.verses.length; i++) {
+            const passageVerses = String(passage.verses[i])
+            let verses = passageVerses.split("-").map(Number)
+
+            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] &&
+                    this.chapterVerses[passage.book][passage.chapter].includes(verse)
+
+                if (!isValidVerse) {
+                    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) {