codexparser 0.1.83 → 0.1.84

package/.trunk/trunk.yaml

@@ -7,7 +7,7 @@ cli:
 plugins:
   sources:
     - id: trunk
-      ref: v1.7.0
+      ref: v1.7.1
       uri: https://github.com/trunk-io/plugins
 # Many linters and tools depend on runtimes - configure them here. (https://docs.trunk.io/runtimes)
 runtimes:
@@ -17,11 +17,11 @@ runtimes:
 # This is the section where you manage your linters. (https://docs.trunk.io/check/configuration)
 lint:
   enabled:
-    - checkov@3.2.445
+    - checkov@3.2.446
     - git-diff-check
     - markdownlint@0.45.0
     - osv-scanner@2.0.3
-    - prettier@3.6.0
+    - prettier@3.6.1
     - trufflehog@3.89.2
 actions:
   disabled:

package/package.json

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

@@ -85,11 +85,6 @@ class CodexParser {
         return singleChapterBook ? singleChapterBook[book][chapter] || [] : this.chapterVerses[book]?.[chapter] || []
     }
 
-    /**
-     * Scans text for scripture references and stores them in `this.found`.
-     * @param {string} text - The text to scan.
-     * @returns {CodexParser} The parser instance for method chaining.
-     */
     /**
      * Scans text for scripture references and stores them in `this.found`.
      * @param {string} text - The text to scan.
@@ -101,6 +96,8 @@ class CodexParser {
         this.found = []
         // Minimal normalization: fix periods before numbers, remove trailing periods
         let normalizedText = text.replace(/\.(?=\d)/g, ":").replace(/(\b[A-Za-z]+)\.(?=\s|$)/g, "$1")
+        console.log(`Input text: ${text}`)
+        console.log(`Normalized text: ${normalizedText}`)
         const lowercaseBibleFullNames = fullNames.map((book) => book.toLowerCase())
         const lowercaseBibleAbbreviations = abbreviations.map((abbr) => abbr.toLowerCase())
         const lowerCaseText = normalizedText.toLowerCase()
@@ -121,7 +118,7 @@ class CodexParser {
 
         while (i < lowerCaseText.length) {
             let foundBook = null
-            let startIndex = -1
+            let bookStartIndex = -1
             let matchedLength = 0
 
             // Skip whitespace and special characters before checking for book
@@ -130,11 +127,13 @@ class CodexParser {
             }
             if (i >= lowerCaseText.length) break
 
+            console.log(`Scanning at index ${i}: ${lowerCaseText.slice(i, i + 10)}...`)
+
             for (let j = 0; j < lowercaseBibleFullNames.length; j++) {
                 const book = lowercaseBibleFullNames[j]
                 if (lowerCaseText.startsWith(book, i) && book.length > matchedLength) {
                     foundBook = fullNames[j]
-                    startIndex = i
+                    bookStartIndex = i
                     matchedLength = book.length
                 }
             }
@@ -144,24 +143,42 @@ class CodexParser {
                     const abbreviation = lowercaseBibleAbbreviations[k]
                     if (lowerCaseText.startsWith(abbreviation, i) && abbreviation.length > matchedLength) {
                         foundBook = this.abbreviations[abbreviations[k]]
-                        startIndex = i
+                        bookStartIndex = i
                         matchedLength = abbreviation.length
                     }
                 }
             }
 
             if (foundBook) {
+                console.log(`Found book: ${foundBook} at index ${bookStartIndex}, length ${matchedLength}`)
                 i += matchedLength
                 let chapterVerse = ""
                 const references = []
-                const startOfReference = startIndex
+                let refStartIndex = bookStartIndex // Start of reference (including book) in normalizedText
+                let originalRefStartIndex = bookStartIndex // Start in original text
 
                 while (i < normalizedText.length && isValidChapterVerseChar(normalizedText[i])) {
-                    if (isNextBibleBook(i)) break
+                    if (isNextBibleBook(i)) {
+                        console.log(`Next book detected at index ${i}, stopping reference parsing`)
+                        break
+                    }
                     if (normalizedText[i] === ";") {
-                        const formattedReference = chapterVerse.trim().replace(/[^a-zA-Z0-9]+$/, "")
-                        if (formattedReference) references.push(formattedReference)
+                        const formattedReference = chapterVerse.trim()
+                        if (formattedReference) {
+                            const refEndIndex = i
+                            references.push({
+                                ref: formattedReference,
+                                start: refStartIndex,
+                                end: refEndIndex,
+                            })
+                            console.log(
+                                `Reference found: ${formattedReference}, normalized indices ${refStartIndex}-${refEndIndex}`
+                            )
+                        }
                         chapterVerse = ""
+                        refStartIndex = i + 1
+                        const semicolonIndex = text.indexOf(";", originalRefStartIndex)
+                        originalRefStartIndex = semicolonIndex !== -1 ? semicolonIndex + 1 : refStartIndex
                         i++
                         continue
                     }
@@ -170,25 +187,29 @@ class CodexParser {
                 }
 
                 if (chapterVerse.trim().length > 0) {
-                    const formattedReference = chapterVerse.trim().replace(/[^a-zA-Z0-9]+$/, "")
-                    if (formattedReference) references.push(formattedReference)
-                }
-
-                // Set endIndex to the current position
-                let endIndex = i
-                const suffixData = detectSuffix(i)
-                const suffix = suffixData ? suffixData.suffix : null
-                if (suffixData) {
-                    endIndex += suffixData.length
-                    i += suffixData.length
+                    const formattedReference = chapterVerse.trim()
+                    if (formattedReference) {
+                        const refEndIndex = i
+                        references.push({
+                            ref: formattedReference,
+                            start: refStartIndex,
+                            end: refEndIndex,
+                        })
+                        console.log(
+                            `Final reference found: ${formattedReference}, normalized indices ${refStartIndex}-${refEndIndex}`
+                        )
+                    }
                 }
 
-                // Trim endIndex to exclude trailing whitespace or non-reference characters
-                while (endIndex > startOfReference && /[\s]/.test(normalizedText[endIndex - 1])) {
-                    endIndex--
-                }
+                // Align indices with original text
+                const originalBookText = text.slice(bookStartIndex, bookStartIndex + matchedLength)
+                const originalBookStartIndex =
+                    text.indexOf(originalBookText, bookStartIndex) !== -1
+                        ? text.indexOf(originalBookText, bookStartIndex)
+                        : bookStartIndex
+                console.log(`Original book text: ${originalBookText}, original start index: ${originalBookStartIndex}`)
 
-                references.forEach((ref) => {
+                references.forEach(({ ref, start, end }, refIndex) => {
                     let type
                     if (ref.includes(":")) {
                         if (ref.includes("-")) {
@@ -212,14 +233,56 @@ class CodexParser {
                         type = "single_chapter"
                     }
 
+                    // Construct full reference text for original text
+                    const fullRefText = `${originalBookText} ${ref.replace(":", ".")}`
+                    const suffixData = detectSuffix(end)
+                    const suffix = suffixData ? suffixData.suffix : null
+                    let refEndIndex = end
+                    if (suffixData) {
+                        refEndIndex += suffixData.length
+                        i += suffixData.length // Skip suffix
+                    }
+
+                    // Map to original text
+                    let originalStartIndex =
+                        text.indexOf(fullRefText, originalRefStartIndex) !== -1
+                            ? text.indexOf(fullRefText, originalRefStartIndex)
+                            : originalBookStartIndex
+                    console.log(
+                        `Searching for fullRefText: ${fullRefText} at index ${originalRefStartIndex}, found at ${originalStartIndex}`
+                    )
+
+                    let originalEndIndex = originalStartIndex + fullRefText.length
+                    let originalText = text.slice(originalStartIndex, originalEndIndex)
+
+                    // Adjust for suffix in original text
+                    if (suffixData) {
+                        originalEndIndex += suffixData.length
+                        originalText = text.slice(originalStartIndex, originalEndIndex)
+                    }
+
+                    // Trim trailing whitespace from originalText
+                    while (originalEndIndex > originalStartIndex && /[\s]/.test(text[originalEndIndex - 1])) {
+                        originalEndIndex--
+                        originalText = text.slice(originalStartIndex, originalEndIndex)
+                    }
+
+                    console.log(
+                        `Reference ${
+                            refIndex + 1
+                        }: ${originalText}, original indices ${originalStartIndex}-${originalEndIndex}, type: ${type}, suffix: ${
+                            suffix || "none"
+                        }, search text: ${fullRefText}`
+                    )
+
                     this.found.push({
                         book: foundBook,
                         reference: ref,
-                        startIndex: startOfReference + 1,
-                        endIndex: endIndex + 1,
+                        startIndex: originalStartIndex,
+                        endIndex: originalEndIndex,
                         version: suffix || null,
                         type,
-                        originalText: text.slice(startOfReference, endIndex), // Use original text
+                        originalText: originalText,
                     })
                 })
             } else {
@@ -227,6 +290,7 @@ class CodexParser {
             }
         }
 
+        console.log(`Found references: ${JSON.stringify(this.found, null, 2)}`)
         return this
     }
 
@@ -276,6 +340,7 @@ class CodexParser {
 
             // Clean reference for parsing
             let cleanReference = passage.reference.replace(/\s*(LXX|MT)$/i, "").trim()
+            console.log(`Parsing reference: ${cleanReference}, type: ${passage.type}`)
             if (cleanReference.endsWith(",")) {
                 cleanReference = cleanReference.slice(0, -1).trim()
             }
@@ -283,6 +348,7 @@ class CodexParser {
             // Handle book-only or empty references
             if (!cleanReference && this.config.booksOnly) {
                 parsedPassage.type = "book_only"
+                console.log(`Book-only reference: ${book}`)
             } else if (!cleanReference || cleanReference.match(/^\d+\s*[:;]?\s*$/)) {
                 const chapterMatch = cleanReference.match(/\d+/) || ["1"]
                 const chapter = Number(chapterMatch[0])
@@ -294,8 +360,18 @@ class CodexParser {
                     const endVerse = chapterVerses[chapterVerses.length - 1]
                     parsedPassage.verses = [`${startVerse}-${endVerse}`]
                 }
+                console.log(`Single chapter: ${chapter}, verses: ${parsedPassage.verses}`)
+            } else if (passage.type === "comma_separated_verses") {
+                // Handle comma-separated verses (e.g., "1:7,18")
+                const [chapter, verses] = cleanReference.split(":")
+                parsedPassage.chapter = Number(chapter)
+                parsedPassage.verses = verses.split(",").map((v) => v.trim())
+                console.log(`Comma-separated verses: chapter ${chapter}, verses ${parsedPassage.verses}`)
             } else {
                 this.parseReferenceParts(parsedPassage, cleanReference)
+                console.log(
+                    `Parsed with parseReferenceParts: chapter ${parsedPassage.chapter}, verses ${parsedPassage.verses}`
+                )
             }
 
             parsedPassage.passages = this.populate(parsedPassage)
@@ -315,6 +391,7 @@ class CodexParser {
             } else {
                 parsedPassage.abbr = parsedPassage.original
             }
+            console.log(`Abbreviation set: ${parsedPassage.abbr}`)
 
             if (parsedPassage.type === this.MULTI_CHAPTER_RANGE) {
                 this.handleMultiChapterRange(parsedPassage, cleanReference)
@@ -340,6 +417,7 @@ class CodexParser {
                     chapter: lastPassage.chapter,
                     verse: lastPassage.verse,
                 }
+                console.log(`Start: ${JSON.stringify(parsedPassage.start)}, End: ${JSON.stringify(parsedPassage.end)}`)
             }
 
             if (!parsedPassage.version) {
@@ -354,9 +432,9 @@ class CodexParser {
         })
 
         this.versification()
+        console.log(`Final passages: ${JSON.stringify(this.passages, null, 2)}`)
         return this
     }
-
     /**
      * Parses reference parts into chapter and verse components.
      * @param {Object} passage - The passage object to populate.