codexparser 0.1.38 → 0.1.40

package/package.json

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

@@ -56,144 +56,163 @@ class CodexParser {
      * @return {CodexParser} - Returns the instance itself, enabling method chaining.
      */
     scan(text) {
-        // Initialize the `found` property as an empty array to store matched references.
-        this.found = []
-
-        // Retrieve the full names of Bible books (both Old and New Testament).
+        // Combine Old and New Testament book names into a single array
         const fullNames = [...this.bible.old, ...this.bible.new]
 
-        // Retrieve the abbreviations for Bible books from the `abbreviations` object.
+        // Retrieve all abbreviation keys from the abbreviations object
         const abbreviations = Object.keys(this.abbreviations)
 
-        // Convert all Bible book names and abbreviations to lowercase for case-insensitive matching.
+        // Initialize the `found` array to store the results
+        this.found = []
+
+        // 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())
-
-        // Convert the input text to lowercase for consistent comparison.
         const lowerCaseText = text.toLowerCase()
 
-        // Initialize an index pointer `i` to iterate through the text.
-        let i = 0
+        let i = 0 // Index pointer to iterate through the input text
 
-        // Helper function to check if a character is valid for chapter or verse notation.
+        /**
+         * 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 next sequence in the text matches a Bible book name or abbreviation.
+        /**
+         * 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 if the upcoming text starts with any full Bible book name.
+            // Check for full Bible book names
             for (const book of lowercaseBibleFullNames) {
                 if (textAfterCurrentPosition.startsWith(book)) return true
             }
 
-            // Check if the upcoming text starts with any Bible book abbreviation.
+            // Check for Bible book abbreviations
             for (const abbr of lowercaseBibleAbbreviations) {
                 if (textAfterCurrentPosition.startsWith(abbr)) return true
             }
 
-            // If no match is found, return false.
-            return false
+            return false // No match found
         }
 
-        // Helper function to detect suffixes like "LXX" or "MT" in the text after a given index.
+        /**
+         * 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)
             return suffixMatch ? suffixMatch[0].toUpperCase() : null
         }
 
-        // Main loop: Iterate through the input text to search for Bible references.
+        // Iterate through the input text to detect and process Bible references
         while (i < lowerCaseText.length) {
-            let foundBook = null // Stores the matched Bible book name.
-            let foundIndex = -1 // Tracks the index where the match starts.
-            let matchedLength = 0 // Tracks the length of the matched book name.
+            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
 
-            // Check for matches against full Bible book names.
+            // Search for full Bible book names in the text
             for (let j = 0; j < lowercaseBibleFullNames.length; j++) {
                 const book = lowercaseBibleFullNames[j]
-
-                // If the text at the current index matches a book name and is longer than any previously matched name.
                 if (lowerCaseText.startsWith(book, i) && book.length > matchedLength) {
-                    foundBook = fullNames[j] // Store the original case-sensitive book name.
-                    foundIndex = i // Update the starting index of the match.
-                    matchedLength = book.length // Update the length of the match.
+                    foundBook = fullNames[j] // Store the original book name (case-sensitive)
+                    foundIndex = i
+                    matchedLength = book.length // Update the match length
                 }
             }
 
-            // If no match was found against full names, try matching against abbreviations.
+            // 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 the text at the current index matches an abbreviation.
                     if (lowerCaseText.startsWith(abbreviation, i)) {
-                        foundBook = abbreviations[k] // Store the original abbreviation.
-                        foundIndex = i // Update the starting index of the match.
-                        matchedLength = abbreviation.length // Update the length of the match.
+                        foundBook = abbreviations[k]
+                        foundIndex = i
+                        matchedLength = abbreviation.length
                     }
                 }
             }
 
-            // If a Bible book is found.
+            // If a Bible book is found
             if (foundBook) {
-                i += matchedLength // Move the pointer past the matched book name.
-                let chapterVerse = "" // Initialize a variable to accumulate chapter and verse information.
-                const references = [] // Array to store individual chapter and verse references.
+                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
 
-                // Secondary loop: Extract chapter and verse information after the book name.
+                // Extract chapter and verse references
                 while (i < text.length && isValidChapterVerseChar(text[i])) {
-                    // Break if another Bible book starts at the current position.
-                    if (isNextBibleBook(i)) break
+                    if (isNextBibleBook(i)) break // Stop if a new Bible book is detected
 
-                    // Handle semicolon-delimited references (e.g., "John 3:16; 4:5").
+                    // Handle semicolon-separated references (indicates a new reference)
                     if (text[i] === ";") {
                         const formattedReference = chapterVerse
                             .trim()
-                            .replace(/\.+/g, ":") // Replace dots (.) with colons (:).
-                            .replace(/[^a-zA-Z0-9:]+$/, "") // Remove trailing invalid characters.
-
-                        if (formattedReference) references.push(formattedReference) // Add the formatted reference to the list.
-                        chapterVerse = "" // Reset the chapterVerse accumulator.
-                        i++ // Move past the semicolon.
+                            .replace(/\./g, ":")
+                            .replace(/[^a-zA-Z0-9]+$/, "")
+                        if (formattedReference) references.push(formattedReference)
+                        chapterVerse = "" // Reset for the next reference
+                        i++
                         continue
                     }
 
-                    // Accumulate valid characters for the chapterVerse.
                     chapterVerse += text[i]
                     i++
                 }
 
-                // Handle any remaining chapterVerse after the loop ends.
+                // Process the last detected chapter/verse reference
                 if (chapterVerse.trim().length > 0) {
                     const formattedReference = chapterVerse
                         .trim()
-                        .replace(/\.+/g, ":") // Replace dots (.) with colons (:).
-                        .replace(/[^a-zA-Z0-9:]+$/, "") // Remove trailing invalid characters.
-
-                    if (formattedReference) references.push(formattedReference) // Add the formatted reference to the list.
+                        .replace(/\./g, ":")
+                        .replace(/[^a-zA-Z0-9]+$/, "")
+                    if (formattedReference) references.push(formattedReference)
                 }
 
-                // Detect any suffix (e.g., "LXX" or "MT") after the chapter/verse reference.
+                // Detect any suffix (e.g., "LXX" or "MT") after the chapter/verse reference
                 const suffix = detectSuffix(i)
 
-                // Process each extracted reference to classify its type and store it in the `found` array.
+                // 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"
+                            }
+                        } else if (ref.includes(",")) {
+                            type = "comma_separated_verses" // Example: "8:23,24"
+                        } else {
+                            type = "chapter_verse" // Example: "8:23"
+                        }
+                    } else if (ref.includes("-")) {
+                        type = "chapter_range" // Example: "8-9"
+                    } else {
+                        type = "single_chapter" // Example: "8"
+                    }
+
                     this.found.push({
-                        book: foundBook, // The matched book name.
-                        reference: ref.replace(/^:/, "").trim().replace(/\s+/gim, ""), // Format the reference.
-                        index: foundIndex, // The starting index of the match in the original text.
-                        type: ref.includes(":") ? "chapter_verse" : "single_chapter", // Determine the type of reference.
-                        version: suffix || null, // Add detected suffix (e.g., "LXX" or "MT").
+                        book: foundBook,
+                        reference: ref,
+                        index: foundIndex,
+                        version: suffix || null,
+                        type,
                     })
                 })
             } else {
-                // If no book is found, move the pointer forward by one character.
-                i++
+                i++ // Move to the next character if no book is found
             }
         }
 
-        // Return the current instance for method chaining.
-        return this
+        return this // Return the current instance for method chaining
     }
 
     bibleVersion(version) {
@@ -229,7 +248,6 @@ class CodexParser {
                 index: passage.index,
                 version: this._handleVersion(passage.version, testament),
             }
-
             const parts = passage.reference.split(",")
             const isSingleChapter = this.singleChapterBook.some((singleChapterBook) => singleChapterBook[book])
 
@@ -297,10 +315,8 @@ class CodexParser {
             parsedPassage.passages = this.populate(parsedPassage)
             parsedPassage.scripture = this.scripturize(parsedPassage)
             parsedPassage.valid = this._isValid(parsedPassage, passage.reference)
-
             return parsedPassage
         })
-
         this.versification()
         return this
     }
@@ -397,6 +413,7 @@ class CodexParser {
     populate(parsedPassage) {
         const passages = []
         const { book, chapter, verses, type } = parsedPassage
+        this._setVersion(parsedPassage)
         if (type === "single_chapter") {
             // Handle single chapter references
             if (this.chapterVerses[book] && this.chapterVerses[book][chapter]) {
@@ -426,7 +443,6 @@ class CodexParser {
             }
         } 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 = [
                 {
@@ -439,16 +455,30 @@ class CodexParser {
                 },
             ]
 
-            // Iterate over the range of chapters and verses
-            for (let i = refs[0].chapter; i <= refs[1].chapter; i++) {
-                const startVerse = i === refs[0].chapter ? refs[0].verse : 1
-                const endVerse = i === refs[1].chapter ? refs[1].verse : this.chapterVerses[book][i].length
+            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)
 
-                for (let j = startVerse; j <= endVerse; j++) {
+                // 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: i,
-                        verse: j,
+                        chapter,
+                        verse: currentVerse,
                     })
                 }
             }
@@ -527,49 +557,63 @@ class CodexParser {
      * @return {object} The object with the human-readable name, chapter and verses and a hash.
      */
     scripturize(passage) {
-        const { book, chapter, passages } = passage
+        const { book, chapter, passages, to } = passage
 
         // Extract verses from the passages array
-        const verses = passages.map((p) => p.verse)
+        const verses = passages.map((p) => ({ chapter: p.chapter, verse: p.verse }))
         let formattedVerses = ""
 
-        if (verses.length === 1) {
-            // If there is only one verse
-            formattedVerses = verses[0].toString()
-        } else if (verses.length === 2 && verses[1] === verses[0] + 1) {
-            // If there are exactly two verses and they are consecutive, use a comma
-            formattedVerses = `${verses[0]},${verses[1]}`
+        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 {
-            // For more than two verses, or non-consecutive verses
-            let ranges = []
-            let tempRange = [verses[0]]
-
-            for (let i = 1; i < verses.length; i++) {
-                if (verses[i] === verses[i - 1] + 1) {
-                    // If the verse is consecutive, add to tempRange
-                    tempRange.push(verses[i])
-                } else {
-                    // If not consecutive, finalize tempRange
-                    ranges.push(tempRange)
-                    tempRange = [verses[i]]
+            // 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)
+
+                formattedVerses = ranges
+                    .map((range) => (range.length > 1 ? `${range[0]}-${range[range.length - 1]}` : range[0]))
+                    .join(",")
             }
-            ranges.push(tempRange) // Push the last range
 
-            // Format ranges: convert consecutive numbers to ranges, non-consecutive remain separate
-            formattedVerses = ranges
-                .map((range) => (range.length > 1 ? `${range[0]}-${range[range.length - 1]}` : range[0]))
-                .join(",")
+            formattedVerses = `${chapter}:${formattedVerses}`
         }
 
         // Format the final passage
-        const colon = formattedVerses ? ":" : ""
-        const full = `${book} ${chapter}${colon}${formattedVerses}`.trim()
+        const full = `${book} ${formattedVerses}`.trim()
         const hash = full.toLowerCase().replace(/ /g, "_").replace(/:/g, ".").replace(/-/g, ".").replace(/,/g, ".")
 
         return {
             passage: full,
-            cv: `${chapter}${colon}${formattedVerses}`,
+            cv: formattedVerses,
             hash,
         }
     }