codexparser 0.1.77 → 0.1.79

package/package.json

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

@@ -87,44 +87,24 @@ class CodexParser {
      */
     scan(text) {
         const fullNames = [...this.bible.old, ...this.bible.new]
-        const abbreviations = Object.keys(this.abbreviations)
+        const abbreviations = Object.keys(this.abbreviations).filter((abbr) => abbr.length >= 3)
         this.found = []
 
         // Normalize text: remove curly quotes, replace periods before numbers with colons
-        let normalizedText = text
-            .replace(/[“”]/g, "") // Remove curly quotes
-            .replace(/\.(?=\d)/g, ":")
+        let normalizedText = text.replace(/[“”]/g, "").replace(/\.(?=\d)/g, ":")
         const lowerCaseText = normalizedText.toLowerCase()
         let i = 0
 
         while (i < lowerCaseText.length) {
             let foundBook = null
-            let startIndex = -1
+            let startIndex = i
             let matchedLength = 0
-            let hasOpeningParen = false
-            let parenStartIndex = -1
-
-            // Skip whitespace
-            while (i < lowerCaseText.length && /\s/.test(lowerCaseText[i])) {
-                i++
-            }
-            if (i >= lowerCaseText.length) break
-
-            // Check for opening parenthesis
-            if (i < lowerCaseText.length && lowerCaseText[i] === "(") {
-                hasOpeningParen = true
-                parenStartIndex = i
-                i++
-            }
-
-            // Record potential start of reference
-            startIndex = i
 
             // Check for book names or abbreviations
             for (let book of fullNames) {
                 if (
                     lowerCaseText.startsWith(book.toLowerCase(), i) &&
-                    (i + book.length >= lowerCaseText.length || /[\s:;\d]/.test(lowerCaseText[i + book.length]))
+                    (i + book.length >= lowerCaseText.length || /[\s:;]/.test(lowerCaseText[i + book.length]))
                 ) {
                     foundBook = book
                     matchedLength = book.length
@@ -135,7 +115,7 @@ class CodexParser {
                 for (let abbr of abbreviations) {
                     if (
                         lowerCaseText.startsWith(abbr.toLowerCase(), i) &&
-                        (i + abbr.length >= lowerCaseText.length || /[\s:;\d]/.test(lowerCaseText[i + abbr.length]))
+                        (i + abbr.length >= lowerCaseText.length || /[\s:;]/.test(lowerCaseText[i + abbr.length]))
                     ) {
                         foundBook = this.abbreviations[abbr]
                         matchedLength = abbr.length
@@ -145,105 +125,116 @@ class CodexParser {
             }
 
             if (foundBook) {
-                // Check if book is followed by a valid reference when booksOnly is false
-                let isFollowedByReference = false
-                if (!this.config.booksOnly && !hasOpeningParen) {
-                    let j = i + matchedLength
+                let j = i + matchedLength
+                let currentBook = foundBook
+                let currentStartIndex = startIndex
+
+                // Process multiple references for the same book
+                while (j < lowerCaseText.length) {
+                    let chapterVerse = ""
+                    let hasColon = false
+                    let version = null
+                    let refStart = j
+
                     // Skip spaces
                     while (j < lowerCaseText.length && /\s/.test(lowerCaseText[j])) {
+                        chapterVerse += normalizedText[j]
                         j++
                     }
-                    // Check for a digit (chapter number) to start a valid reference
-                    if (j < lowerCaseText.length && /\d/.test(lowerCaseText[j])) {
-                        isFollowedByReference = true
+                    refStart = j // Update start after spaces
+
+                    // Next character must be a digit or version suffix
+                    if (j < lowerCaseText.length) {
+                        const nextChar = lowerCaseText[j]
+                        const isVersion = lowerCaseText.substring(j).match(/^(lxx|mt)\b/i)
+                        if (!/\d/.test(nextChar) && !isVersion && !this.config.booksOnly) {
+                            break
+                        }
+                    } else if (!this.config.booksOnly) {
+                        break
                     }
-                } else {
-                    isFollowedByReference = true // Allow if booksOnly or in parentheses
-                }
 
-                if (!isFollowedByReference) {
-                    i++
-                    continue
-                }
-
-                i += matchedLength
-                let chapterVerse = ""
-                let hasColon = false
-
-                // Capture space after book
-                if (i < normalizedText.length && normalizedText[i] === " ") {
-                    chapterVerse += " "
-                    i++
-                }
-
-                // Capture chapter-verse (allow digits, colons, commas, dashes, spaces)
-                while (i < lowerCaseText.length && (/[\d:,\-]/.test(normalizedText[i]) || normalizedText[i] === " ")) {
-                    if (normalizedText[i] === ":") hasColon = true
-                    chapterVerse += normalizedText[i]
-                    i++
-                }
-
-                // Only proceed if valid reference or booksOnly is true
-                if ((hasColon && chapterVerse.trim().length > 0) || (this.config.booksOnly && !chapterVerse.trim())) {
-                    let endIndex = i
-                    let version = null
+                    // Capture chapter-verse
+                    while (j < lowerCaseText.length && /\d/.test(lowerCaseText[j])) {
+                        chapterVerse += normalizedText[j]
+                        j++
+                    }
+                    while (
+                        j < lowerCaseText.length &&
+                        (/[\d:,\-;]/.test(normalizedText[j]) || normalizedText[j] === " ")
+                    ) {
+                        if (normalizedText[j] === ":") hasColon = true
+                        chapterVerse += normalizedText[j]
+                        if (normalizedText[j] === ";") break
+                        j++
+                    }
 
-                    // Detect suffix
-                    const suffixMatch = normalizedText.substring(i).match(/\b(LXX|MT)\b/i)
+                    // Check for version suffix
+                    let endIndex = j
+                    const suffixMatch = normalizedText.substring(j).match(/\b(LXX|MT)\b/i)
                     if (suffixMatch) {
                         version = suffixMatch[0].toUpperCase()
                         endIndex += suffixMatch[0].length
-                        i += suffixMatch[0].length
-                    }
-
-                    // Handle closing parenthesis
-                    if (hasOpeningParen && i < lowerCaseText.length && normalizedText[i] === ")") {
-                        endIndex = i + 1
-                        i++
+                        j += suffixMatch[0].length
                     }
 
-                    // Use original text for reference only (exclude parentheses)
-                    const originalText = normalizedText.slice(startIndex, hasOpeningParen ? endIndex - 1 : endIndex)
-
-                    // Determine type
-                    let type
+                    // Store the reference
                     const ref = chapterVerse.trim()
-                    if (this.config.booksOnly && !ref) {
-                        type = "book_only"
-                    } else if (ref.includes(":")) {
-                        if (ref.includes("-")) {
-                            const [start, end] = ref.split("-")
-                            const startParts = start.split(":")
-                            const endParts = end.split(":")
-                            type =
-                                startParts.length > 1 &&
-                                endParts.length > 1 &&
-                                startParts[0].trim() !== endParts[0].trim()
-                                    ? "multi_chapter_verse_range"
-                                    : "chapter_verse_range"
-                        } else if (ref.includes(",")) {
-                            type = "comma_separated_verses"
+                    if (ref.length > 0 || version || this.config.booksOnly) {
+                        let type
+                        if (this.config.booksOnly && !ref) {
+                            type = "book_only"
+                        } else if (ref.includes(":")) {
+                            if (ref.includes("-")) {
+                                const [start, end] = ref.split("-")
+                                const startParts = start.split(":")
+                                const endParts = end.split(":")
+                                type =
+                                    startParts.length > 1 &&
+                                    endParts.length > 1 &&
+                                    startParts[0].trim() !== endParts[0].trim()
+                                        ? "multi_chapter_verse_range"
+                                        : "chapter_verse_range"
+                            } else if (ref.includes(",")) {
+                                type = "comma_separated_verses"
+                            } else {
+                                type = "chapter_verse"
+                            }
+                        } else if (ref.includes("-")) {
+                            type = "chapter_range"
+                        } else if (/\d/.test(ref)) {
+                            type = "single_chapter"
                         } else {
-                            type = "chapter_verse"
+                            type = "book_only"
+                        }
+
+                        this.found.push({
+                            book: currentBook,
+                            reference: ref,
+                            startIndex: currentStartIndex,
+                            endIndex,
+                            version,
+                            type,
+                            originalText: normalizedText.slice(currentStartIndex, endIndex),
+                        })
+                    }
+
+                    // Handle semicolon for next reference
+                    if (j < lowerCaseText.length && lowerCaseText[j] === ";") {
+                        j++ // Move past semicolon
+                        currentStartIndex = j // Reset start for next reference
+                        // Skip spaces after semicolon
+                        while (j < lowerCaseText.length && /\s/.test(lowerCaseText[j])) {
+                            j++
                         }
-                    } else if (ref.includes("-")) {
-                        type = "chapter_range"
-                    } else {
-                        type = "single_chapter"
+                        continue // Process next reference
                     }
 
-                    this.found.push({
-                        book: foundBook,
-                        reference: ref,
-                        startIndex: hasOpeningParen ? parenStartIndex : startIndex,
-                        endIndex,
-                        version,
-                        type,
-                        originalText,
-                    })
-                } else {
-                    i = startIndex + 1
+                    // Exit if no semicolon or end of reference
+                    break
                 }
+
+                i = j
             } else {
                 i++
             }
@@ -296,10 +287,31 @@ class CodexParser {
                 abbr: null,
             }
 
-            this.parseReferenceParts(parsedPassage, passage.reference.split(","))
+            // Clean reference for parsing, removing version suffix
+            let cleanReference = passage.reference
+            if (passage.version) {
+                cleanReference = cleanReference.replace(/\s*(LXX|MT)$/i, "").trim()
+            }
+
+            // Handle chapter-only references (e.g., "113 :" or "113")
+            if (!cleanReference || cleanReference.match(/^\d+\s*[:;]?\s*$/)) {
+                const chapterMatch = cleanReference.match(/\d+/) || ["1"]
+                const chapter = Number(chapterMatch[0])
+                parsedPassage.chapter = chapter
+                parsedPassage.type = this.SINGLE_CHAPTER
+                const chapterVerses = this.getChapterVerses(book, chapter)
+                if (chapterVerses.length) {
+                    const startVerse = chapterVerses[0]
+                    const endVerse = chapterVerses[chapterVerses.length - 1]
+                    parsedPassage.verses = [`${startVerse}-${endVerse}`]
+                }
+            } else {
+                this.parseReferenceParts(parsedPassage, cleanReference.split(","))
+            }
+
             parsedPassage.passages = this.populate(parsedPassage)
             parsedPassage.scripture = this.scripturize(parsedPassage)
-            parsedPassage.valid = this._isValid(parsedPassage, passage.reference)
+            parsedPassage.valid = this._isValid(parsedPassage, cleanReference)
 
             // Set abbr property using SBL-style abbreviations
             const sblEntry = Object.entries(this.sblAbbreviations).find(
@@ -307,16 +319,16 @@ class CodexParser {
             )
             if (sblEntry) {
                 const { value, abbr } = sblEntry[1]
+                const ref = passage.reference.replace(/\s*(LXX|MT)$/i, "").trim()
                 parsedPassage.abbr = abbr
-                    ? `${value}. ${passage.reference}${passage.version ? " " + passage.version : ""}`
-                    : `${value} ${passage.reference}${passage.version ? " " + passage.version : ""}`
+                    ? `${value}. ${ref}${passage.version ? " " + passage.version : ""}`
+                    : `${value} ${ref}${passage.version ? " " + passage.version : ""}`
             } else {
-                // Fallback to original
                 parsedPassage.abbr = parsedPassage.original
             }
 
             if (parsedPassage.type === this.MULTI_CHAPTER_RANGE) {
-                this.handleMultiChapterRange(parsedPassage, passage.reference)
+                this.handleMultiChapterRange(parsedPassage, cleanReference)
             } else {
                 delete parsedPassage.to
             }
@@ -370,6 +382,22 @@ class CodexParser {
             if (!part) return // Skip empty parts from trailing commas
             const isFirstPart = index === 0
 
+            // Handle chapter-only references (e.g., "113 :" or "113")
+            if (!part.includes(":") && !part.includes("-") && !singleChapterBook) {
+                const chapter = Number(part.replace(/[^0-9]/g, "")) // Extract number, remove trailing colon
+                if (chapter > 0) {
+                    passage.chapter = chapter
+                    passage.type = this.SINGLE_CHAPTER
+                    const chapterVerses = this.getChapterVerses(passage.book, chapter)
+                    if (chapterVerses.length) {
+                        const startVerse = chapterVerses[0]
+                        const endVerse = chapterVerses[chapterVerses.length - 1]
+                        passage.verses = [`${startVerse}-${endVerse}`]
+                    }
+                    return
+                }
+            }
+
             if (part.includes(":")) {
                 this.parseChapterVerse(passage, part, isFirstPart)
             } else if (singleChapterBook) {
@@ -381,7 +409,6 @@ class CodexParser {
             }
         })
     }
-
     /**
      * Parses chapter-verse references (e.g., "3:16").
      * @param {Object} passage - The passage object.