codexparser 0.1.41 → 0.1.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexparser",
-  "version": "0.1.41",
+  "version": "0.1.42",
   "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,115 +65,86 @@ 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
 
@@ -182,21 +153,19 @@ class CodexParser {
                             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"
-                            }
+                            type =
+                                startParts[0].trim() !== endParts[0].trim()
+                                    ? "multi_chapter_verse_range"
+                                    : "chapter_verse_range"
                         } 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 +177,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 +201,143 @@ 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)) {
+                        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
+                            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
+                                )
+                            }
+                            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.
@@ -333,6 +352,7 @@ class CodexParser {
 
     _searchVersificationDifferences(passage) {
         const { book, chapter, version } = passage
+        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])) {
@@ -361,7 +381,6 @@ class CodexParser {
     versification() {
         this.passages.forEach((passage) => {
             const hasVersification = this.versificationDifferences[passage.book]
-
             passage.passages.forEach((subPassage) => {
                 // Apply general versification differences
                 if (hasVersification) {
@@ -412,79 +431,57 @@ class CodexParser {
      */
     populate(parsedPassage) {
         const passages = []
-        const { book, chapter, verses, type } = parsedPassage
-        this._setVersion(parsedPassage)
+        const { book, chapter, verses, type, to } = parsedPassage
+
+        this._setVersion(parsedPassage) // 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 +493,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 +560,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 +627,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,7 +646,9 @@ class CodexParser {
         })
 
         const noDuplicates2 = [...new Set(newPassages)]
+
         const parsed = this.parse(noDuplicates2.join(" // ")).getPassages()
+
         return this.join(parsed)
     }
 
@@ -662,7 +664,6 @@ class CodexParser {
 
         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}`