codexparser 0.1.79 → 0.1.81

package/.trunk/configs/.markdownlint.yaml

@@ -0,0 +1,2 @@
+# Prettier friendly markdownlint config (all formatting rules disabled)
+extends: markdownlint/style/prettier

package/.trunk/trunk.yaml

@@ -0,0 +1,32 @@
+# This file controls the behavior of Trunk: https://docs.trunk.io/cli
+# To learn more about the format of this file, see https://docs.trunk.io/reference/trunk-yaml
+version: 0.1
+cli:
+  version: 1.24.0
+# Trunk provides extensibility via plugins. (https://docs.trunk.io/plugins)
+plugins:
+  sources:
+    - id: trunk
+      ref: v1.7.0
+      uri: https://github.com/trunk-io/plugins
+# Many linters and tools depend on runtimes - configure them here. (https://docs.trunk.io/runtimes)
+runtimes:
+  enabled:
+    - node@22.16.0
+    - python@3.10.8
+# This is the section where you manage your linters. (https://docs.trunk.io/check/configuration)
+lint:
+  enabled:
+    - checkov@3.2.445
+    - git-diff-check
+    - markdownlint@0.45.0
+    - osv-scanner@2.0.3
+    - prettier@3.6.0
+    - trufflehog@3.89.2
+actions:
+  disabled:
+    - trunk-announce
+    - trunk-check-pre-push
+    - trunk-fmt-pre-commit
+  enabled:
+    - trunk-upgrade-available

package/package.json

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

@@ -23,7 +23,7 @@ class CodexParser {
     /**
      * Initializes the parser with default properties and data.
      */
-    constructor() {
+    constructor(config = {}) {
         this.found = [] // Array to store detected references
         this.passages = [] // Array to store parsed passages
         this.bible = bible // Bible data (Old/New Testament books)
@@ -53,9 +53,12 @@ class CodexParser {
         this.CHAPTER_RANGE = "chapter_range"
         this.MULTI_CHAPTER_RANGE = "multi_chapter_verse_range"
         this.config = {
-            booksOnly: false,
+            booksOnly: config.booksOnly ?? false,
+            invalid_sequence_strategy: config.invalid_sequence_strategy ?? "include",
+            invalid_passage_strategy: config.invalid_passage_strategy ?? "include",
         }
     }
+
     /**
      * Sets configuration options for the parser.
      * @param {Object} config - Configuration options.
@@ -65,6 +68,8 @@ class CodexParser {
     options(config) {
         this.config = {
             booksOnly: config.booksOnly ?? false,
+            invalid_sequence_strategy: config.invalid_sequence_strategy ?? this.config.invalid_sequence_strategy,
+            invalid_passage_strategy: config.invalid_passage_strategy ?? this.config.invalid_passage_strategy,
         }
         return this
     }
@@ -87,159 +92,213 @@ class CodexParser {
      */
     scan(text) {
         const fullNames = [...this.bible.old, ...this.bible.new]
-        const abbreviations = Object.keys(this.abbreviations).filter((abbr) => abbr.length >= 3)
+        const abbreviations = Object.keys(this.abbreviations)
         this.found = []
-
-        // Normalize text: remove curly quotes, replace periods before numbers with colons
-        let normalizedText = text.replace(/[“”]/g, "").replace(/\.(?=\d)/g, ":")
+        // Normalize text for parsing but keep original for originalText
+        let normalizedText = text
+            .replace(/[“”]/g, "") // Remove curly quotes
+            .replace(/\.(?=\d)/g, ":") // Replace periods before digits with colons (e.g., "Re13.8" -> "Re13:8")
+            .replace(/\s+/g, " ") // Normalize multiple spaces to single
+        const lowercaseBibleFullNames = fullNames.map((book) => book.toLowerCase())
+        const lowercaseBibleAbbreviations = abbreviations.map((abbr) => abbr.toLowerCase())
         const lowerCaseText = normalizedText.toLowerCase()
         let i = 0
 
+        console.log("[Scan] Input text:", text)
+        console.log("[Scan] Normalized text:", normalizedText)
+
+        const isValidChapterVerseChar = (char) => /[^A-Za-z]/.test(char) // Non-letter characters
+        const isNextBibleBook = (startIndex) => {
+            const textAfterCurrentPosition = lowerCaseText.substring(startIndex).trim()
+            // Check if the text starts with a book name or abbreviation followed by a digit
+            return (
+                lowercaseBibleFullNames.some((book) => {
+                    if (textAfterCurrentPosition.startsWith(book)) {
+                        const nextIndex = startIndex + book.length
+                        const nextChar = lowerCaseText[nextIndex]
+                        return nextChar && /\d/.test(nextChar)
+                    }
+                    return false
+                }) ||
+                lowercaseBibleAbbreviations.some((abbr) => {
+                    if (textAfterCurrentPosition.startsWith(abbr)) {
+                        const nextIndex = startIndex + abbr.length
+                        const nextChar = lowerCaseText[nextIndex]
+                        return nextChar && (/\d/.test(nextChar) || /\./.test(nextChar))
+                    }
+                    return false
+                })
+            )
+        }
+        const detectSuffix = (startIndex, inputText) => {
+            const suffixMatch = inputText.substring(startIndex).match(/\b(LXX|MT)\b/i)
+            return suffixMatch ? { version: suffixMatch[0].toUpperCase(), length: suffixMatch[0].length } : null
+        }
+
         while (i < lowerCaseText.length) {
             let foundBook = null
-            let startIndex = i
             let matchedLength = 0
+            let originalBookText = ""
+            let startIndex = i
 
-            // Check for book names or abbreviations
-            for (let book of fullNames) {
+            // Check full book names
+            for (let j = 0; j < lowercaseBibleFullNames.length; j++) {
+                const book = lowercaseBibleFullNames[j]
                 if (
-                    lowerCaseText.startsWith(book.toLowerCase(), i) &&
-                    (i + book.length >= lowerCaseText.length || /[\s:;]/.test(lowerCaseText[i + book.length]))
+                    lowerCaseText.startsWith(book, i) &&
+                    (i + book.length >= lowerCaseText.length || /\d/.test(lowerCaseText[i + book.length]))
                 ) {
-                    foundBook = book
+                    foundBook = fullNames[j]
                     matchedLength = book.length
-                    break
+                    originalBookText = text.slice(i, i + book.length)
+                    console.log(`[Scan] Matched full book name: "${foundBook}" at index ${i}`)
                 }
             }
+
+            // Check abbreviations
             if (!foundBook) {
-                for (let abbr of abbreviations) {
-                    if (
-                        lowerCaseText.startsWith(abbr.toLowerCase(), i) &&
-                        (i + abbr.length >= lowerCaseText.length || /[\s:;]/.test(lowerCaseText[i + abbr.length]))
-                    ) {
-                        foundBook = this.abbreviations[abbr]
-                        matchedLength = abbr.length
-                        break
+                for (let k = 0; k < lowercaseBibleAbbreviations.length; k++) {
+                    const abbreviation = lowercaseBibleAbbreviations[k]
+                    const abbrPattern = abbreviation.replace(/\./g, "\\.?")
+                    const regex = new RegExp(`^${abbrPattern}(\\.?\\s*\\d)`, "i")
+                    const match = lowerCaseText.slice(i).match(regex)
+                    if (match) {
+                        foundBook = this.abbreviations[abbreviations[k]]
+                        matchedLength = match[0].length - match[1].length // Exclude chapter-verse part
+                        originalBookText = text.slice(i, i + matchedLength)
+                        console.log(
+                            `[Scan] Matched abbreviation: "${abbreviations[k]}" -> "${foundBook}" at index ${i}`
+                        )
                     }
                 }
             }
 
             if (foundBook) {
-                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++
+                i += matchedLength
+                let chapterVerse = ""
+                let originalChapterVerseText = ""
+                const references = []
+
+                // Capture chapter-verse until a letter (potential new book) or semicolon
+                while (i < normalizedText.length && isValidChapterVerseChar(normalizedText[i])) {
+                    if (isNextBibleBook(i)) {
+                        console.log(`[Scan] Detected next book at index ${i}, breaking`)
+                        break
                     }
-                    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
+                    if (normalizedText[i] === ";") {
+                        const formattedReference = chapterVerse.trim().replace(/[^a-zA-Z0-9:,\-]+$/g, "")
+                        if (formattedReference) {
+                            // Find the last digit in the reference
+                            const lastDigitMatch = formattedReference.match(/\d(?=[^0-9]*$)/)
+                            let endIndex = i - 1 // Default to position before semicolon
+                            if (lastDigitMatch) {
+                                const lastDigitIndex = formattedReference.lastIndexOf(lastDigitMatch[0])
+                                endIndex = startIndex + matchedLength + lastDigitIndex
+                            }
+                            references.push({
+                                reference: formattedReference,
+                                originalText: (originalBookText + originalChapterVerseText).trim(),
+                                startIndex,
+                                endIndex,
+                            })
                         }
-                    } else if (!this.config.booksOnly) {
-                        break
+                        chapterVerse = ""
+                        originalChapterVerseText = ""
+                        originalBookText = foundBook // Reuse book for semicolon-separated references
+                        startIndex = i + 1 // Start of next reference
+                        i++
+                        continue
                     }
+                    chapterVerse += normalizedText[i]
+                    originalChapterVerseText += text[i]
+                    i++
+                }
 
-                    // 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++
+                // Add any remaining reference
+                if (chapterVerse.trim().length > 0) {
+                    const formattedReference = chapterVerse.trim().replace(/[^a-zA-Z0-9:,\-]+$/g, "")
+                    if (formattedReference) {
+                        // Find the last digit in the reference
+                        const lastDigitMatch = formattedReference.match(/\d(?=[^0-9]*$)/)
+                        let endIndex = i - 1 // Default to last character
+                        if (lastDigitMatch) {
+                            const lastDigitIndex = formattedReference.lastIndexOf(lastDigitMatch[0])
+                            endIndex = startIndex + matchedLength + lastDigitIndex
+                        }
+                        references.push({
+                            reference: formattedReference,
+                            originalText: (originalBookText + originalChapterVerseText).trim(),
+                            startIndex,
+                            endIndex,
+                        })
                     }
+                }
 
-                    // 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
-                        j += suffixMatch[0].length
+                // Process each reference
+                references.forEach((refObj) => {
+                    // Detect version suffix (LXX or MT)
+                    let version = null
+                    let originalText = refObj.originalText
+                    const suffix = detectSuffix(i, text)
+                    if (suffix) {
+                        version = suffix.version
+                        originalText += ` ${version}`
+                        i += suffix.length
+                        // Update endIndex if version suffix follows a digit
+                        if (refObj.endIndex === i - suffix.length - 1) {
+                            refObj.endIndex = i - 1
+                        }
                     }
 
-                    // Store the reference
-                    const ref = chapterVerse.trim()
-                    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"
+                    let type
+                    let ref = refObj.reference.replace(/^\.\s*/, "") // Remove leading period and space
+                    if (this.config.booksOnly && !ref) {
+                        type = "book_only"
+                    } else if (ref.includes(":")) {
+                        if (ref.includes("-")) {
+                            const [start, end] = ref.split("-").map((s) => s.trim())
+                            const startParts = start.split(":").map((s) => s.trim())
+                            const endParts = end.split(":").map((s) => s.trim())
+                            type =
+                                startParts.length > 1 && endParts.length > 1 && startParts[0] !== endParts[0]
+                                    ? "multi_chapter_verse_range"
+                                    : "chapter_verse_range"
+                        } else if (ref.includes(",")) {
+                            type = "comma_separated_verses"
                         } else {
-                            type = "book_only"
+                            type = "chapter_verse"
                         }
-
-                        this.found.push({
-                            book: currentBook,
-                            reference: ref,
-                            startIndex: currentStartIndex,
-                            endIndex,
-                            version,
-                            type,
-                            originalText: normalizedText.slice(currentStartIndex, endIndex),
-                        })
+                    } else if (ref.includes("-")) {
+                        type = "chapter_range"
+                    } else if (/\d/.test(ref)) {
+                        type = "single_chapter"
+                    } else {
+                        type = "book_only"
                     }
 
-                    // 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++
-                        }
-                        continue // Process next reference
+                    const referenceObj = {
+                        book: foundBook,
+                        reference: ref,
+                        version,
+                        type,
+                        originalText,
+                        startIndex: refObj.startIndex,
+                        endIndex: refObj.endIndex,
                     }
+                    this.found.push(referenceObj)
+                    console.log(`[Scan] Stored reference: ${JSON.stringify(referenceObj)}`)
+                })
 
-                    // Exit if no semicolon or end of reference
-                    break
+                // Skip any trailing spaces after the reference
+                while (i < lowerCaseText.length && /\s/.test(lowerCaseText[i])) {
+                    i++
                 }
-
-                i = j
             } else {
                 i++
             }
         }
 
+        console.log("[Scan] Final found references:", JSON.stringify(this.found, null, 2))
         return this
     }
 
@@ -287,14 +346,16 @@ class CodexParser {
                 abbr: null,
             }
 
-            // Clean reference for parsing, removing version suffix
-            let cleanReference = passage.reference
-            if (passage.version) {
-                cleanReference = cleanReference.replace(/\s*(LXX|MT)$/i, "").trim()
+            // Clean reference for parsing
+            let cleanReference = passage.reference.replace(/\s*(LXX|MT)$/i, "").trim()
+            if (cleanReference.endsWith(",")) {
+                cleanReference = cleanReference.slice(0, -1).trim()
             }
 
-            // Handle chapter-only references (e.g., "113 :" or "113")
-            if (!cleanReference || cleanReference.match(/^\d+\s*[:;]?\s*$/)) {
+            // Handle book-only or empty references
+            if (!cleanReference && this.config.booksOnly) {
+                parsedPassage.type = "book_only"
+            } else if (!cleanReference || cleanReference.match(/^\d+\s*[:;]?\s*$/)) {
                 const chapterMatch = cleanReference.match(/\d+/) || ["1"]
                 const chapter = Number(chapterMatch[0])
                 parsedPassage.chapter = chapter
@@ -306,7 +367,7 @@ class CodexParser {
                     parsedPassage.verses = [`${startVerse}-${endVerse}`]
                 }
             } else {
-                this.parseReferenceParts(parsedPassage, cleanReference.split(","))
+                this.parseReferenceParts(parsedPassage, cleanReference)
             }
 
             parsedPassage.passages = this.populate(parsedPassage)
@@ -371,20 +432,40 @@ class CodexParser {
     /**
      * Parses reference parts into chapter and verse components.
      * @param {Object} passage - The passage object to populate.
-     * @param {string[]} parts - Array of reference parts.
+     * @param {string} reference - The reference string.
      * @private
      */
-    parseReferenceParts(passage, parts) {
+    parseReferenceParts(passage, reference) {
         const singleChapterBook = this.singleChapterBook.find((b) => Object.keys(b)[0] === passage.book)
+        const parts = reference
+            .split(",")
+            .map((part) => part.trim())
+            .filter((part) => part)
 
         parts.forEach((part, index) => {
-            part = part.trim()
-            if (!part) return // Skip empty parts from trailing commas
             const isFirstPart = index === 0
 
-            // Handle chapter-only references (e.g., "113 :" or "113")
+            // Handle multi-chapter ranges (e.g., "2:1-3:19")
+            if (part.includes("-") && part.includes(":")) {
+                const [start, end] = part.split("-").map((s) => s.trim())
+                const startParts = start.split(/[:.]/).map((s) => s.trim())
+                const endParts = end.split(/[:.]/).map((s) => s.trim())
+                if (startParts.length > 1 && endParts.length > 1 && startParts[0] !== endParts[0]) {
+                    passage.type = this.MULTI_CHAPTER_RANGE
+                    passage.chapter = Number(startParts[0])
+                    passage.verses = [startParts[1] || "1"]
+                    passage.to = {
+                        book: passage.book,
+                        chapter: Number(endParts[0]),
+                        verses: [endParts[1] || "1"],
+                    }
+                    return
+                }
+            }
+
+            // Handle chapter-only references (e.g., "3")
             if (!part.includes(":") && !part.includes("-") && !singleChapterBook) {
-                const chapter = Number(part.replace(/[^0-9]/g, "")) // Extract number, remove trailing colon
+                const chapter = Number(part.replace(/[^0-9]/g, ""))
                 if (chapter > 0) {
                     passage.chapter = chapter
                     passage.type = this.SINGLE_CHAPTER
@@ -409,6 +490,7 @@ class CodexParser {
             }
         })
     }
+
     /**
      * Parses chapter-verse references (e.g., "3:16").
      * @param {Object} passage - The passage object.
@@ -417,10 +499,18 @@ class CodexParser {
      * @private
      */
     parseChapterVerse(passage, part, isFirstPart) {
-        const [chapter, verse] = part.split(":")
+        const [chapter, verse] = part.split(/[:.]/).map((s) => s.trim())
         if (isFirstPart) passage.chapter = Number(chapter)
-        passage.type = verse.includes("-") ? this.CHAPTER_VERSE_RANGE : this.CHAPTER_VERSE
-        passage.verses.push(verse.includes("-") ? verse : Number(verse))
+        passage.type = verse.includes("-")
+            ? this.CHAPTER_VERSE_RANGE
+            : verse.includes(",")
+            ? this.COMMA_SEPARATED
+            : this.CHAPTER_VERSE
+        if (verse.includes(",")) {
+            passage.verses.push(...verse.split(",").map((v) => v.trim()))
+        } else {
+            passage.verses.push(verse)
+        }
     }
 
     /**
@@ -440,9 +530,13 @@ class CodexParser {
             passage.chapter = 1
             passage.verses.push(part)
             passage.type = this.CHAPTER_VERSE_RANGE
+        } else if (part.includes(",")) {
+            passage.chapter = 1
+            passage.verses.push(...part.split(",").map((v) => v.trim()))
+            passage.type = this.COMMA_SEPARATED
         } else {
             const num = Number(part)
-            if (num > 1 || !isWholeChapter) {
+            if (num > 0) {
                 passage.chapter = 1
                 passage.verses.push(num)
                 passage.type = this.CHAPTER_VERSE
@@ -508,13 +602,13 @@ class CodexParser {
      */
     handleMultiChapterRange(passage, reference) {
         const parts = reference.split(",")
-        const lastPart = parts[parts.length - 1]
-        const [endChapter, endVerse] = lastPart.split(":")
+        const lastPart = parts[parts.length - 1].trim()
+        const [endChapter, endVerse] = lastPart.split(/[:.]/).map((s) => s.trim())
         if (endChapter !== String(passage.chapter)) {
             passage.to = {
                 book: passage.book,
                 chapter: Number(endChapter),
-                verses: endVerse.includes("-") ? [endVerse] : [Number(endVerse)],
+                verses: endVerse ? [endVerse] : ["1"],
             }
         }
     }
@@ -563,17 +657,16 @@ class CodexParser {
                     }
                 }
             }
-            // Ensure unique verses and update the singleChapterBook entry
             singleChapterBook[book][chapter] = Array.from(new Set(singleChapterBook[book][chapter]))
-            return singleChapterBook[book] // Return updated chapter data
+            return singleChapterBook[book]
         }
 
         // Handle all other books using chapterVerses
         if (!this.chapterVerses[book][chapter]) {
-            return // No data for this book/chapter
+            return
         }
         if (!this.versificationDifferences[book]) {
-            return // No versification differences
+            return
         }
         for (const [key, value] of Object.entries(this.versificationDifferences[book])) {
             if (value[version].startsWith(`${chapter}:`)) {
@@ -583,8 +676,8 @@ class CodexParser {
                 }
             }
         }
-        this.chapterVerses[book][chapter] = Array.from(this.chapterVerses[book][chapter])
-        return this.chapterVerses // Return updated chapterVerses
+        this.chapterVerses[book][chapter] = Array.from(new Set(this.chapterVerses[book][chapter]))
+        return this.chapterVerses
     }
 
     /**
@@ -656,24 +749,31 @@ class CodexParser {
 
         if (type === this.CHAPTER_RANGE) {
             const passages = []
-            for (let ch = chapter; ch <= to.chapter; ch++) {
-                const chapterVerses = this.getChapterVerses(book, ch)
-                passages.push(
-                    ...this.expandVerses(book, ch, [`${chapterVerses[0]}-${chapterVerses[chapterVerses.length - 1]}`])
-                )
+            if (to && to.chapter) {
+                for (let ch = chapter; ch <= to.chapter; ch++) {
+                    const chapterVerses = this.getChapterVerses(book, ch)
+                    passages.push(
+                        ...this.expandVerses(book, ch, [
+                            `${chapterVerses[0]}-${chapterVerses[chapterVerses.length - 1]}`,
+                        ])
+                    )
+                }
             }
             return passages
         }
 
         if (type === this.MULTI_CHAPTER_RANGE) {
             const passages = []
-            const startVerse = verses[0].includes("-") ? Number(verses[0].split("-")[0]) : Number(verses[0])
-            const endVerse = to.verses[0].includes("-") ? Number(to.verses[0].split("-")[1]) : Number(to.verses[0])
+            const startVerse = verses[0]?.includes("-") ? Number(verses[0].split("-")[0]) : Number(verses[0]) || 1
+            const endVerse = to?.verses?.[0]?.includes("-")
+                ? Number(to.verses[0].split("-")[1])
+                : Number(to?.verses?.[0]) || 1
+            const endChapter = to?.chapter || chapter
 
-            for (let ch = chapter; ch <= to.chapter; ch++) {
+            for (let ch = chapter; ch <= endChapter; ch++) {
                 const chapterVerses = this.getChapterVerses(book, ch)
                 const from = ch === chapter ? startVerse : chapterVerses[0]
-                const toVerse = ch === to.chapter ? endVerse : chapterVerses[chapterVerses.length - 1]
+                const toVerse = ch === endChapter ? endVerse : chapterVerses[chapterVerses.length - 1]
                 passages.push(...this.expandVerses(book, ch, [`${from}-${toVerse}`]))
             }
             return passages
@@ -700,7 +800,10 @@ class CodexParser {
                     passages.push({ book, chapter, verse: i })
                 }
             } else {
-                passages.push({ book, chapter, verse: Number(verse) })
+                const verseNum = Number(verse)
+                if (!isNaN(verseNum) && verseNum > 0) {
+                    passages.push({ book, chapter, verse: verseNum })
+                }
             }
         })
         return passages
@@ -716,15 +819,13 @@ class CodexParser {
             book = book[0]
         }
         book = book.toLowerCase()
-        // Check if book is an abbreviation
         let bookified = this.abbreviations[Object.keys(this.abbreviations).find((abbr) => abbr.toLowerCase() === book)]
         if (bookified) {
             return bookified
         }
-        // Check if book is a full name
         bookified =
             this.bible.new.find((b) => b.toLowerCase() === book) || this.bible.old.find((b) => b.toLowerCase() === book)
-        return bookified || book // Fallback to input if not found
+        return bookified || book
     }
 
     /**
@@ -816,7 +917,7 @@ class CodexParser {
             if (verses.length === 1) {
                 return `${chapter}:${verses[0]}`
             }
-            const isRange = verses.every((v, i, arr) => i === 0 || v === arr[i - 1] + 1)
+            const isRange = verses.every((v, i, arr) => i === 0 || Number(v) === Number(arr[i - 1]) + 1)
             if (isRange) {
                 return `${chapter}:${verses[0]}-${verses[verses.length - 1]}`
             }
@@ -829,9 +930,7 @@ class CodexParser {
                 passage.to.chapter,
                 passage.to.verses
             )}`
-        } else if (passage.type === "chapter_verse_range") {
-            combined += ` ${formatChapterVerse(passage.chapter, passage.verses)}`
-        } else if (passage.type === "comma_separated_verses") {
+        } else if (passage.type === "chapter_verse_range" || passage.type === "comma_separated_verses") {
             combined += ` ${formatChapterVerse(passage.chapter, passage.verses)}`
         } else if (passage.type === "chapter_range" && passage.to) {
             combined += ` ${passage.chapter}-${passage.to.chapter}`
@@ -857,7 +956,7 @@ class CodexParser {
 
     /**
      * Combines multiple passages into a single reference.
-     * @param {Object[]} [passages=this.passages] - Array of passages to combine, defaults to this.passages.
+     * @param {Object[]} [passages=this.passages] - Array of passages to combine.
      * @returns {Object} Combined passage object.
      */
     combine(passages = this.passages) {
@@ -920,7 +1019,7 @@ class CodexParser {
         sortedChapters.forEach((chapter) => {
             const verses = Array.from(chapterVerses[chapter])
                 .map(Number)
-                .filter((verse) => verse > 0) // Exclude invalid verse 0
+                .filter((verse) => verse > 0)
                 .sort((a, b) => a - b)
             if (verses.length > 0) {
                 const mergedVerses = this.mergeRanges(verses)
@@ -972,7 +1071,6 @@ class CodexParser {
                     : Math.max(...Array.from(chapterVerses[lastChapter]).filter((verse) => verse > 0)),
         }
 
-        // Reattach the reference method to the combined passage
         combined.reference = function () {
             return this.scripture.passage
         }
@@ -1111,7 +1209,7 @@ class CodexParser {
                 : [Number(verseRange)]
 
             for (const v of verseNumbers) {
-                if (!chapterVerses.includes(v)) {
+                if (isNaN(v) || v <= 0 || !chapterVerses.includes(v)) {
                     return this.validationError(104, `Verse number ${v} does not exist in ${book} ${chapter}`)
                 }
             }
@@ -1171,21 +1269,18 @@ class CodexParser {
             const { originalText, abbr, original } = passage
             const newReference = useAbbreviations ? abbr : original
 
-            const regex = new RegExp(`${originalText}`, "g")
+            const regex = new RegExp(`${originalText.replace(/([.*+?^${}()|[\]\\])/g, "\\$1")}`, "g")
 
-            // Find all matches
             const matches = [...result.matchAll(regex)]
             if (matches.length > 0) {
-                // Process matches in reverse to avoid index shifting
                 for (let j = matches.length - 1; j >= 0; j--) {
                     const match = matches[j]
                     const startIndex = match.index
                     const endIndex = startIndex + match[0].length
-                    const leadingSpace = match[1] || "" // Capture leading spaces
+                    const leadingSpace = match[1] || ""
                     const hasOpeningParen = match[2] === "("
                     const hasClosingParen = match[3] === ")"
-                    const trailingSpace = match[4] || " " // Capture trailing spaces
-                    // Preserve parentheses if present
+                    const trailingSpace = match[4] || " "
                     const replacement =
                         hasOpeningParen && hasClosingParen
                             ? `${leadingSpace}(${newReference})${trailingSpace}`
@@ -1197,6 +1292,7 @@ class CodexParser {
 
         return result
     }
+
     /**
      * Checks if all references in the passages array are from the same book.
      * @returns {boolean} True if all passages are from the same book, false otherwise.

package/src/versifications/psalms.js

@@ -6807,269 +6807,264 @@ module.exports = {
         eng: "88:19",
     },
     "89:1": {
-        lxx: "88:1",
-        mt: "89:1",
-        eng: "89:1",
-    },
-    "89:2": {
         lxx: "88:2",
         mt: "89:2",
-        eng: "89:2",
+        eng: "89:1",
     },
-    "89:3": {
+    "89:2": {
         lxx: "88:3",
         mt: "89:3",
-        eng: "89:3",
+        eng: "89:2",
     },
-    "89:4": {
+    "89:3": {
         lxx: "88:4",
         mt: "89:4",
-        eng: "89:4",
+        eng: "89:3",
     },
-    "89:5": {
+    "89:4": {
         lxx: "88:5",
         mt: "89:5",
-        eng: "89:5",
+        eng: "89:4",
     },
-    "89:6": {
+    "89:5": {
         lxx: "88:6",
         mt: "89:6",
-        eng: "89:6",
+        eng: "89:5",
     },
-    "89:7": {
+    "89:6": {
         lxx: "88:7",
         mt: "89:7",
-        eng: "89:7",
+        eng: "89:6",
     },
-    "89:8": {
+    "89:7": {
         lxx: "88:8",
         mt: "89:8",
-        eng: "89:8",
+        eng: "89:7",
     },
-    "89:9": {
+    "89:8": {
         lxx: "88:9",
         mt: "89:9",
-        eng: "89:9",
+        eng: "89:8",
     },
-    "89:10": {
+    "89:9": {
         lxx: "88:10",
         mt: "89:10",
-        eng: "89:10",
+        eng: "89:9",
     },
-    "89:11": {
+    "89:10": {
         lxx: "88:11",
         mt: "89:11",
-        eng: "89:11",
+        eng: "89:10",
     },
-    "89:12": {
+    "89:11": {
         lxx: "88:12",
         mt: "89:12",
-        eng: "89:12",
+        eng: "89:11",
     },
-    "89:13": {
+    "89:12": {
         lxx: "88:13",
         mt: "89:13",
-        eng: "89:13",
+        eng: "89:12",
     },
-    "89:14": {
+    "89:13": {
         lxx: "88:14",
         mt: "89:14",
-        eng: "89:14",
+        eng: "89:13",
     },
-    "89:15": {
+    "89:14": {
         lxx: "88:15",
         mt: "89:15",
-        eng: "89:15",
+        eng: "89:14",
     },
-    "89:16": {
+    "89:15": {
         lxx: "88:16",
         mt: "89:16",
-        eng: "89:16",
+        eng: "89:15",
     },
-    "89:17": {
+    "89:16": {
         lxx: "88:17",
         mt: "89:17",
-        eng: "89:17",
+        eng: "89:16",
     },
-    "89:18": {
+    "89:17": {
         lxx: "88:18",
         mt: "89:18",
-        eng: "89:18",
+        eng: "89:17",
     },
-    "89:19": {
+    "89:18": {
         lxx: "88:19",
         mt: "89:19",
-        eng: "89:19",
+        eng: "89:18",
     },
-    "89:20": {
+    "89:19": {
         lxx: "88:20",
         mt: "89:20",
-        eng: "89:20",
+        eng: "89:19",
     },
-    "89:21": {
+    "89:20": {
         lxx: "88:21",
         mt: "89:21",
-        eng: "89:21",
+        eng: "89:20",
     },
-    "89:22": {
+    "89:21": {
         lxx: "88:22",
         mt: "89:22",
-        eng: "89:22",
+        eng: "89:21",
     },
-    "89:23": {
+    "89:22": {
         lxx: "88:23",
         mt: "89:23",
-        eng: "89:23",
+        eng: "89:22",
     },
-    "89:24": {
+    "89:23": {
         lxx: "88:24",
         mt: "89:24",
-        eng: "89:24",
+        eng: "89:23",
     },
-    "89:25": {
+    "89:24": {
         lxx: "88:25",
         mt: "89:25",
-        eng: "89:25",
+        eng: "89:24",
     },
-    "89:26": {
+    "89:25": {
         lxx: "88:26",
         mt: "89:26",
-        eng: "89:26",
+        eng: "89:25",
     },
-    "89:27": {
+    "89:26": {
         lxx: "88:27",
         mt: "89:27",
-        eng: "89:27",
+        eng: "89:26",
     },
-    "89:28": {
+    "89:27": {
         lxx: "88:28",
         mt: "89:28",
-        eng: "89:28",
+        eng: "89:27",
     },
-    "89:29": {
+    "89:28": {
         lxx: "88:29",
         mt: "89:29",
-        eng: "89:29",
+        eng: "89:28",
     },
-    "89:30": {
+    "89:29": {
         lxx: "88:30",
         mt: "89:30",
-        eng: "89:30",
+        eng: "89:29",
     },
-    "89:31": {
+    "89:30": {
         lxx: "88:31",
         mt: "89:31",
-        eng: "89:31",
+        eng: "89:30",
     },
-    "89:32": {
+    "89:31": {
         lxx: "88:32",
         mt: "89:32",
-        eng: "89:32",
+        eng: "89:31",
     },
-    "89:33": {
+    "89:32": {
         lxx: "88:33",
         mt: "89:33",
-        eng: "89:33",
+        eng: "89:32",
     },
-    "89:34": {
+    "89:33": {
         lxx: "88:34",
         mt: "89:34",
-        eng: "89:34",
+        eng: "89:33",
     },
-    "89:35": {
+    "89:34": {
         lxx: "88:35",
         mt: "89:35",
-        eng: "89:35",
+        eng: "89:34",
     },
-    "89:36": {
+    "89:35": {
         lxx: "88:36",
         mt: "89:36",
-        eng: "89:36",
+        eng: "89:35",
     },
-    "89:37": {
+    "89:36": {
         lxx: "88:37",
         mt: "89:37",
-        eng: "89:37",
+        eng: "89:36",
     },
-    "89:38": {
+    "89:37": {
         lxx: "88:38",
         mt: "89:38",
-        eng: "89:38",
+        eng: "89:37",
     },
-    "89:39": {
+    "89:38": {
         lxx: "88:39",
         mt: "89:39",
-        eng: "89:39",
+        eng: "89:38",
     },
-    "89:40": {
+    "89:39": {
         lxx: "88:40",
         mt: "89:40",
-        eng: "89:40",
+        eng: "89:39",
     },
-    "89:41": {
+    "89:40": {
         lxx: "88:41",
         mt: "89:41",
-        eng: "89:41",
+        eng: "89:40",
     },
-    "89:42": {
+    "89:41": {
         lxx: "88:42",
         mt: "89:42",
-        eng: "89:42",
+        eng: "89:41",
     },
-    "89:43": {
+    "89:42": {
         lxx: "88:43",
         mt: "89:43",
-        eng: "89:43",
+        eng: "89:42",
     },
-    "89:44": {
+    "89:43": {
         lxx: "88:44",
         mt: "89:44",
-        eng: "89:44",
+        eng: "89:43",
     },
-    "89:45": {
+    "89:44": {
         lxx: "88:45",
         mt: "89:45",
-        eng: "89:45",
+        eng: "89:44",
     },
-    "89:46": {
+    "89:45": {
         lxx: "88:46",
         mt: "89:46",
-        eng: "89:46",
+        eng: "89:45",
     },
-    "89:47": {
+    "89:46": {
         lxx: "88:47",
         mt: "89:47",
-        eng: "89:47",
+        eng: "89:46",
     },
-    "89:48": {
+    "89:47": {
         lxx: "88:48",
         mt: "89:48",
-        eng: "89:48",
+        eng: "89:47",
     },
-    "89:49": {
+    "89:48": {
         lxx: "88:49",
         mt: "89:49",
-        eng: "89:49",
+        eng: "89:48",
     },
-    "89:50": {
+    "89:49": {
         lxx: "88:50",
         mt: "89:50",
-        eng: "89:50",
+        eng: "89:49",
     },
-    "89:51": {
+    "89:50": {
         lxx: "88:51",
         mt: "89:51",
-        eng: "89:51",
+        eng: "89:50",
     },
-    "89:52": {
+    "89:51": {
         lxx: "88:52",
         mt: "89:52",
-        eng: "89:52",
+        eng: "89:51",
     },
-    "89:53": {
+    "89:52": {
         lxx: "88:53",
         mt: "89:53",
-        eng: "89:53",
+        eng: "89:52",
     },
     "90:1": {
         lxx: "89:1",