codexparser 0.0.85 → 0.1.0

package/all-scripture-test.js

@@ -10,10 +10,11 @@ const parser = new CodexParser({
     invalid_passage_strategy: "include",
 })
 const text = `Joel 10:13 The passages Luke 2:32 and Lk 1:23 that we are looking at tonight  1 Cor 12:34 2 Cor 3:4 are found Jude 6, in Jude 5, Genesis 2:1 - 3:19,  1 John 3:16-17, 1 Peter 1:1, and Romans 10:13, 15, 17. Please turn in your Bibles.  Ps 109:4,5,6,8.  Isaiah 61.2-3 Mt 5.4`
-const single = "Ge 27.27-29,89-40 Heb 11.20 Heb. 12.17 Jonah 3"
+const single = "Ge 27.27-29,39-41 Heb 11.20 Heb. 12.17 Jonah 3 "
 const jd = "Jd. 5"
 const cor = "1 Cor 12:4 2 Cor 3:4"
 const noSpace = "Re13.8 "
 const ezra = " Ez 1:3"
 const passages = parser.parse(text + single + jd + cor + noSpace + ezra)
+console.log(text + single + jd + cor + noSpace + ezra)
 dump(passages.getPassages())

package/package.json

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

@@ -1,11 +1,10 @@
 const versified = require("./versified")
 const bible = require("./bible")
-const { bookRegex, chapterRegex, verseRegex, scripturesRegex, EzraAbbrv } = require("./regex")
+const { bookRegex, chapterRegex, verseRegex, scripturesRegex } = require("./regex")
 const abbrevations = require("./abbr")
-const crawler = require("bible-passage-reference-parser/js/en_bcv_parser").bcv_parser
-const util = require("util")
 const dump = require("./functions").dump
 const dd = require("./functions").dd
+const chapter_verses = require("./chapterVerseCombine")
 
 class CodexParser {
     constructor() {
@@ -16,135 +15,308 @@ class CodexParser {
         this.chapterRegex = chapterRegex
         this.verseRegex = verseRegex
         this.scripturesRegex = scripturesRegex
-        this.abbrevations = abbrevations
-        this.EzraAbbrv = EzraAbbrv
-        //this.toc = toc
-        this.crawler = new crawler()
+        this.abbreviations = abbrevations
         this.versificationDifferences = versified
+        this.singleChapterBook = [
+            {
+                Jude: {
+                    1: Array.from({ length: 25 }, (_, i) => i + 1),
+                }, // Jude has 25 verses
+            },
+            {
+                "2 John": {
+                    1: Array.from({ length: 13 }, (_, i) => i + 1),
+                }, // 2 John has 13 verses
+            },
+            {
+                "3 John": {
+                    1: Array.from({ length: 15 }, (_, i) => i + 1),
+                }, // 3 John has 15 verses
+            },
+            {
+                Obadiah: {
+                    1: Array.from({ length: 21 }, (_, i) => i + 1),
+                }, // Obadiah has 21 verses
+            },
+            {
+                Philemon: {
+                    1: Array.from({ length: 25 }, (_, i) => i + 1),
+                }, // Philemon has 25 verses
+            },
+        ]
+        this.chapterVerses = chapter_verses
+        this.error = false
     }
 
     /**
-     * Sets the options for the crawler and returns the current instance.
-     *
-     * @param {Object} options - The options to set.
-     * @return {Object} The current instance.
-     */
-    options(options) {
-        this.crawler.set_options(options)
-        return this
-    }
-
-    /**
-     * Scans the input text using the specified scriptures regex.
-     *
-     * @param {string} text - The text to scan.
-     * @return {array} The found passages from the text.
+     * Scans the given text for Bible references, and stores all found references in the `found` property of the instance.
+     * @param {string} text The text to scan for Bible references.
+     * @return {CodexParser} This instance, for method chaining.
      */
     scan(text) {
-        text = text.replace(/Rev(?=\s|\.)/gim, "Revelation")
-        const regex = /(?:He(?=\s?\d+))/g
-        let match
-        const matches = []
-
-        while ((match = regex.exec(text)) !== null) {
-            const index = match.index
-            const book = this.bookify(match[0])
-            matches.push({
-                abbr: match[0],
-                book: book,
-                index: index,
-            })
-        }
-        for (let i = matches.length - 1; i >= 0; i--) {
-            const match = matches[i]
-            text = text.substring(0, match.index) + match.book + text.substring(match.index + match.abbr.length)
+        const fullNames = [...this.bible.old, ...this.bible.new] // Full Bible book names
+        const abbreviations = Object.keys(this.abbreviations) // Abbreviations for Bible books
+
+        this.found = []
+
+        // Convert the Bible book names and text to lowercase for case-insensitive matching
+        const lowercaseBibleFullNames = fullNames.map((book) => book.toLowerCase())
+        const lowercaseBibleAbbreviations = abbreviations.map((abbr) => abbr.toLowerCase())
+        const lowerCaseText = text.toLowerCase()
+
+        let i = 0
+
+        // Function to determine if a character is a valid part of a chapter or verse reference (non-word characters)
+        const isValidChapterVerseChar = (char) => {
+            return /[^A-Za-z]/.test(char) // Allow any non-word characters
         }
-        const bookShouldBeEra = text.match(this.EzraAbbrv)
 
-        if (bookShouldBeEra) {
-            text = text.replace(this.EzraAbbrv, "Ezra")
+        // Function to check if a character at a given index is non-alphabetic or at the boundary of the text
+        const isBoundaryOrNonAlphabetic = (index, text) => {
+            return index < 0 || index >= text.length || /[^a-z]/i.test(text[index])
         }
-        const passages = this.crawler.parse(text).parsed_entities()
 
-        for (let j = 0; j < passages.length; j++) {
-            const passage = passages[j]
-            for (let i = 0; i < passage.entities.length; i++) {
-                const entity = passage.entities[i]
-                this.found.push(entity)
+        // Function to check if the next part of the text starts with a new Bible book (e.g., "2 Corinthians")
+        const isNextBibleBook = (startIndex) => {
+            const textAfterCurrentPosition = lowerCaseText.substring(startIndex).trim()
+
+            // Check if the next part of the text matches any full Bible book name
+            for (let j = 0; j < lowercaseBibleFullNames.length; j++) {
+                if (textAfterCurrentPosition.startsWith(lowercaseBibleFullNames[j])) {
+                    return true // Found another Bible book
+                }
             }
-        }
-    }
 
-    /**
-     * Parses the given reference to extract passages.
-     *
-     * @param {string} reference - The reference to parse.
-     * @return {array} An array of parsed passages.
-     */
-    parse(reference) {
-        if (!reference) {
-            this.passages = []
-            return this
-        }
-        this.passages = []
-        this.scan(reference)
-        const books = []
-        for (let i = 0; i < this.found.length; i++) {
-            const result = this.found[i]
-            if (result.type === "range" && result.start.b !== result.end.b) {
-                const newPassageFound = result.end.b + " " + result.end.c + ":" + result.end.v
-                const newPassageToAdd = this.crawler.parse(newPassageFound).parsed_entities()[0].entities
-                this.found.splice(i + 1, 0, ...newPassageToAdd)
-                result.end.b = result.start.b
-                result.end.c = result.start.c
-                result.end.v = result.start.v
+            for (let j = 0; j < lowercaseBibleAbbreviations.length; j++) {
+                if (textAfterCurrentPosition.startsWith(lowercaseBibleAbbreviations[j])) {
+                    return true // Found another Bible book abbreviation
+                }
             }
 
-            const passage = {
-                book: this.bookify(result.start.b),
-                chapter: result.start.c,
-                verses: this.versify(result),
-                type: result.type,
-                ...result["entities"][0],
+            return false
+        }
+
+        // Loop through the text and check for full names and abbreviations
+        while (i < lowerCaseText.length) {
+            let foundBook = null
+            let foundIndex = -1
+            let matchedLength = 0
+
+            // Check full names first, to prioritize longer matches
+            for (let j = 0; j < lowercaseBibleFullNames.length; j++) {
+                const book = lowercaseBibleFullNames[j]
+
+                // Check if the text starting at position `i` matches the Bible book
+                if (lowerCaseText.startsWith(book, i)) {
+                    if (book.length > matchedLength) {
+                        foundBook = fullNames[j] // Store the original full name
+                        foundIndex = i // Record the index where the book is found
+                        matchedLength = book.length // Update the length of the match
+                    }
+                }
             }
-            passage.testament = this.bible.old.includes(passage.book) ? "old" : "new"
-            let next = this.found[i + 1]
-            if (next && next.type === "integer" && next.start.b === result.end.b && next.end.c === result.start.c) {
-                while (
-                    next &&
-                    next.type === "integer" &&
-                    next.start.b === result.end.b &&
-                    next.end.c === result.start.c
-                ) {
-                    if (next.start.v > result.start.v) {
-                        passage.verses.push(next.start.v)
-                        if (next.end.v !== next.start.v) passage.verses.push(next.end.v)
-                        passage.subType = next.type
+
+            // If no full book name was found, check for abbreviations
+            if (!foundBook) {
+                for (let k = 0; k < lowercaseBibleAbbreviations.length; k++) {
+                    const abbreviation = lowercaseBibleAbbreviations[k]
+                    const abbreviationWithDot = abbreviation + "."
+
+                    // Ensure abbreviation is not part of a larger word (check boundaries)
+                    if (lowerCaseText.startsWith(abbreviationWithDot, i)) {
+                        if (
+                            isBoundaryOrNonAlphabetic(i - 1, lowerCaseText) &&
+                            isBoundaryOrNonAlphabetic(i + abbreviationWithDot.length, lowerCaseText)
+                        ) {
+                            foundBook = abbreviations[k] // Store the abbreviation without the dot
+                            foundIndex = i // Record the index where the abbreviation is found
+                            matchedLength = abbreviationWithDot.length // Update the length of the match to include the dot
+                            break // Exit once found
+                        }
+                    } else if (lowerCaseText.startsWith(abbreviation, i)) {
+                        if (
+                            isBoundaryOrNonAlphabetic(i - 1, lowerCaseText) &&
+                            isBoundaryOrNonAlphabetic(i + abbreviation.length, lowerCaseText)
+                        ) {
+                            if (abbreviation.length > matchedLength) {
+                                foundBook = abbreviations[k] // Store the abbreviation without the dot
+                                foundIndex = i // Record the index where the abbreviation is found
+                                matchedLength = abbreviation.length // Update the length of the match
+                            }
+                        }
                     }
-                    i++
-                    next = this.found[i + 1]
                 }
             }
 
-            if (passage.type === "range" && result.start.b === result.end.b) {
-                if (result.start.c !== result.end.c) {
-                    passage.verses = [result.start.v]
-                    passage.to = {
-                        book: this.bookify(result.end.b),
-                        chapter: result.end.c,
-                        verses: result.end.v,
+            // If a book or abbreviation was found, look for chapter and verse patterns after the book
+            if (foundBook !== null) {
+                i += matchedLength // Skip ahead by the length of the found book
+                let chapterVerse = ""
+
+                while (i < text.length && isValidChapterVerseChar(text[i])) {
+                    // Look ahead to see if the next characters form a new Bible book
+                    if (isNextBibleBook(i)) {
+                        // Stop adding to chapterVerse if a new Bible book is found
+                        break
                     }
+
+                    chapterVerse += text[i]
+                    i++
                 }
+
+                // Trim any period from the end of the reference
+                chapterVerse = chapterVerse.trim().replace(/[.,:;!?]+$/, "")
+
+                // Replace any periods within the reference with colons for easier parsing
+                const formattedReference = chapterVerse.replace(/\./g, ":")
+
+                if (formattedReference.length > 0) {
+                    this.found.push({
+                        book: foundBook,
+                        reference: formattedReference, // Store the formatted reference
+                        index: foundIndex,
+                    })
+                } else {
+                    this.found.push({
+                        book: foundBook,
+                        reference: null,
+                        index: foundIndex,
+                    })
+                }
+            } else {
+                i++
             }
-            passage.original = result.osis
-            passage.scripture = this.scripturize(passage)
-            passage.passages = this.populate(result.entities[0], passage.verses)
-            passage.indices = result.indices
-            this.passages.push(passage)
         }
-        this.found = []
+
+        return this // Return this instance for method chaining
+    }
+
+    parse(reference) {
+        this.scan(reference) // Call scan to populate this.found
+
+        this.passages = this.found.map((passage) => {
+            const book = this.bookify(passage.book)
+
+            // Initialize the parsed passage object
+            const parsedPassage = {
+                original: passage.book + " " + passage.reference,
+                hashed: book.toLowerCase().replace(/\s+/, "_") + "." + passage.reference.replace(/[:\.]/g, "."), // Handle both : and .
+                book: book,
+                chapter: null,
+                verses: [], // Verse stored as an array
+                type: null, // Set type based on reference
+                testament: this.bible.old.find((bible) => bible === book) ? "old" : "new",
+                index: passage.index,
+            }
+
+            // Split reference by commas to handle multiple ranges or verses (e.g., "Ge 27:27-29,39-41")
+            let parts = passage.reference.split(",")
+
+            // Check for single chapter books
+            const singleChapterBook = this.singleChapterBook.find((bible) => bible[book])
+
+            parts.forEach((part) => {
+                part = part.trim() // Clean up spaces
+                // Detect whether it uses ":" or "." for chapter:verse separation
+                const separator = part.includes(":") ? ":" : "."
+
+                if (part.includes("-")) {
+                    // Handle ranges (e.g., "27:27-29" or "39-41")
+
+                    let [start, end] = part.split("-")
+                    // Handle the starting part
+                    let [startChapter, startVerse] = start.includes(separator)
+                        ? start.split(separator)
+                        : [parsedPassage.chapter, start] // Default to same chapter if no chapter is provided
+
+                    parsedPassage.chapter = Number(startChapter) // Set the chapter
+                    // Checks to see if we are in a multi chapter verse range, if so, include only relevant verses from the this.chapterVerse to
+                    // the end of the chapter.
+                    if (start.includes(separator) && end.includes(separator)) {
+                        parsedPassage.verses = this.chapterVerses[book][startChapter].slice(
+                            this.chapterVerses[book][startChapter].indexOf(Number(startVerse))
+                        )
+                    } else {
+                        parsedPassage.verses.push(startVerse.trim())
+                    }
+
+                    // Handle same-chapter ranges (e.g., "27:27-29") and multi-chapter ranges (e.g., "Ex 2:1-3:4")
+                    //TODO:  Need to check for a multi chapter verse range and if fill out the verses before the verse of
+                    // The second chapter.
+                    if (end.includes(separator)) {
+                        let [endChapter, endVerse] = end.split(separator)
+                        if (Number(endChapter) !== Number(startChapter)) {
+                            // Cross-chapter range, set 'to' property
+                            parsedPassage.to = {
+                                book: book,
+                                chapter: Number(endChapter), // End chapter
+                            }
+                            if (endVerse > 1) {
+                                parsedPassage.to.verses = this.chapterVerses[book][Number(endChapter)].slice(
+                                    0,
+                                    this.chapterVerses[book][Number(endChapter)].indexOf(Number(endVerse)) + 1
+                                )
+                            }
+                            parsedPassage.type = "chapter_verse_range" // Set type to chapter range
+                        } else {
+                            // Same-chapter range, just add to the verse array
+                            parsedPassage.verses.push(`${startVerse}-${endVerse}`)
+                        }
+                    } else {
+                        // Single-chapter range (e.g., "27:27-29" or "39-41")
+                        if (!singleChapterBook) {
+                            if (!startChapter) {
+                                // Then we have a chapter range with no verses
+                                parsedPassage.chapter = start
+                                parsedPassage.verses = this.chapterVerses[book][start]
+                                parsedPassage.to = {
+                                    book: book,
+                                    chapter: Number(end),
+                                    verse: this.chapterVerses[book][end],
+                                }
+                            } else {
+                                parsedPassage.verses.push(`${startVerse}-${end}`)
+                            }
+                        } else {
+                            parsedPassage.chapter = 1
+                            parsedPassage.verses.push(`${startVerse}-${end}`)
+                        }
+                    }
+                } else {
+                    // Handle individual chapter:verse references (e.g., "27:27")
+
+                    let [chapterPart, versePart] = part.includes(separator)
+                        ? part.split(separator)
+                        : [parsedPassage.chapter, part]
+                    if (singleChapterBook) {
+                        if (!chapterPart) {
+                            parsedPassage.chapter = 1
+                            parsedPassage.verses.push(versePart) // Add single verse to array
+                        } else {
+                            parsedPassage.chapter = Number(chapterPart)
+                            parsedPassage.verses.push(versePart) // Add single verse to array
+                        }
+                    } else {
+                        // Need to check if chapterPart is undefined
+                        // If it's undefined, then versePart actually is the chapter and we need to populate the
+                        // verses from this.chapterVerses
+
+                        if (chapterPart) {
+                            parsedPassage.chapter = Number(chapterPart)
+                            parsedPassage.verses.push(versePart) // Add single verse to array
+                        } else {
+                            parsedPassage.chapter = Number(versePart)
+                            parsedPassage.verses = this.chapterVerses[book][parsedPassage.chapter]
+                        }
+                    }
+                }
+                parsedPassage.passages = this.populate(parsedPassage)
+            })
+
+            return parsedPassage
+        })
         this.versification()
-        return this
+        return this // Return this instance
     }
 
     versification() {
@@ -170,86 +342,32 @@ class CodexParser {
      * @param {Array} verses - Array of verse numbers to add to the set of passages
      * @return {Array} Array of passage objects
      */
-    populate(entities, verses) {
-        let passages = []
-        for (let i = entities.start.v; i <= entities.end.v; i++) {
-            passages.push({
-                book: this.bookify(entities.start.b),
-                chapter: entities.start.c,
-                verse: i,
-            })
-        }
+    populate(parsedPassage) {
+        const passages = []
 
-        if (verses.length > 1) {
-            const hasDashes = verses.find((verse) => /[-–—]/gim.test(verse))
-            if (hasDashes) {
-                const newVerses = []
-                for (let i = 0; i < verses.length; i++) {
-                    const verse = verses[i]
-                    if (/[-–—]/gim.verse) {
-                        const [start, end] = verse.split("-").map((v) => parseInt(v))
-                        for (let j = start; j <= end; j++) {
-                            newVerses.push(j)
-                        }
-                    } else {
-                        newVerses.push(parseInt(verse))
+        // Helper function to process a parsed passage's verses
+        const processVerses = (chapter, verses, book) => {
+            verses.forEach((verse) => {
+                if (isNaN(verse)) {
+                    const [start, end] = verse.split("-").map(Number) // Handle ranges
+                    for (let i = start; i <= end; i++) {
+                        passages.push({ book, chapter: Number(chapter), verse: i })
                     }
+                } else {
+                    passages.push({ book, chapter: Number(chapter), verse: Number(verse) })
                 }
-                verses = newVerses.sort((a, b) => a - b)
-            }
-            for (let i = 0; i < verses.length; i++) {
-                const passage = {
-                    book: this.bookify(entities.start.b),
-                    chapter: entities.start.c,
-                    verse: verses[i],
-                }
-                if (
-                    !passages.find(
-                        (p) => p.book === passage.book && p.chapter === passage.chapter && p.verse === passage.verse
-                    )
-                ) {
-                    passages.push(passage)
-                }
-            }
+            })
         }
 
-        return [...new Set(passages)]
-    }
-
-    chapterify(chapter) {
-        return chapter.start.c
-    }
+        // Process main passage
+        processVerses(parsedPassage.chapter, parsedPassage.verses, parsedPassage.book)
 
-    /**
-     * Given a passage, return an array of verses. If the passage is a range, the
-     * array will contain a single string in the format "start-end". If the passage
-     * is not a range, the array will contain each verse number as a separate element.
-     *
-     * @param {Object} passage - A passage object from the bible-passage-reference-parser
-     * @return {Array} Array of verse numbers
-     */
-    versify(passage) {
-        if (passage.start.v !== passage.end.v) {
-            if (passage.type === "range" || passage.type === "ff") {
-                if (passage.start.b === passage.end.b) {
-                    return [`${passage.start.v}-${passage.end.v}`]
-                } else {
-                    return [passage.start.v]
-                }
-            } else {
-                if (passage.type !== "bc") {
-                    const verses = []
-                    for (let i = passage.start.v; i <= passage.end.v; i++) {
-                        verses.push(i)
-                    }
-                    return verses
-                } else {
-                    return [passage.start.v + "-" + passage.end.v]
-                }
-            }
-        } else {
-            return [passage.start.v]
+        // Process 'to' object if it exists (for cross-chapter ranges)
+        if (parsedPassage.to) {
+            processVerses(parsedPassage.to.chapter, parsedPassage.to.verses, parsedPassage.to.book)
         }
+
+        return passages
     }
 
     /**
@@ -262,10 +380,10 @@ class CodexParser {
         if (typeof book !== "string") {
             book = book[0]
         }
-        let bookified = Object.keys(this.abbrevations).find((abbr) => {
+        let bookified = Object.keys(this.abbreviations).find((abbr) => {
             return abbr.toLowerCase() === book.toLowerCase()
         })
-        bookified = this.abbrevations[bookified]
+        bookified = this.abbreviations[bookified]
         if (!bookified) {
             bookified = this.bible.new.find(
                 (b) => b.toLowerCase() === book.toLowerCase() && b.toLowerCase().includes(book.toLowerCase())
@@ -315,8 +433,4 @@ class CodexParser {
     }
 }
 
-if (typeof window !== "undefined" && window) {
-    if (!window.CodexParser) window.CodexParser = CodexParser
-}
-
 module.exports = CodexParser

package/src/abbr.js

@@ -236,9 +236,9 @@ const abbrevations = {
     Phlm: "Philemon",
     Phm: "Philemon",
     Philem: "Philemon",
+    He: "Hebrews",
     Hebr: "Hebrews",
     Heb: "Hebrews",
-    He: "Hebrews",
     Jas: "James",
     Jm: "James",
     James: "James",

package/src/bible.js

@@ -19,6 +19,7 @@ module.exports = {
         "Esther",
         "Job",
         "Psalms",
+        "Psalm",
         "Proverbs",
         "Ecclesiastes",
         "Song of Solomon",

package/src/chapterVerseCombine.js

@@ -0,0 +1,63 @@
+module.exports = {
+    Genesis: require("./chapter_verses/genesis"),
+    Exodus: require("./chapter_verses/exodus"),
+    Leviticus: require("./chapter_verses/leviticus"),
+    Numbers: require("./chapter_verses/numbers"),
+    Deuteronomy: require("./chapter_verses/deuteronomy"),
+    Joshua: require("./chapter_verses/joshua"),
+    Judges: require("./chapter_verses/judges"),
+    Ruth: require("./chapter_verses/ruth"),
+    "1 Samuel": require("./chapter_verses/1samuel"),
+    "2 Samuel": require("./chapter_verses/2samuel"),
+    "1 Kings": require("./chapter_verses/1kings"),
+    "2 Kings": require("./chapter_verses/2kings"),
+    "1 Chronicles": require("./chapter_verses/1chronicles.js"),
+    "2 Chronicles": require("./chapter_verses/2chronicles.js"),
+    Ezra: require("./chapter_verses/ezra.js"),
+    Nehemiah: require("./chapter_verses/nehemiah"),
+    Esther: require("./chapter_verses/esther.js"),
+    Job: require("./chapter_verses/job"),
+    Psalms: require("./chapter_verses/psalms"),
+    Proverbs: require("./chapter_verses/proverbs"),
+    Ecclesiastes: require("./chapter_verses/ecclesiastes"),
+    "Song of Songs": require("./chapter_verses/songs"),
+    Isaiah: require("./chapter_verses/isaiah"),
+    Jeremiah: require("./chapter_verses/jeremiah"),
+    Lamentations: require("./chapter_verses/lamentations"),
+    Ezekiel: require("./chapter_verses/ezekiel"),
+    Daniel: require("./chapter_verses/daniel"),
+    Hosea: require("./chapter_verses/hosea"),
+    Joel: require("./chapter_verses/joel"),
+    Amos: require("./chapter_verses/amos"),
+    Jonah: require("./chapter_verses/jonah"),
+    Micah: require("./chapter_verses/micah"),
+    Nahum: require("./chapter_verses/nahum"),
+    Habakkuk: require("./chapter_verses/habakkuk.js"),
+    Zephaniah: require("./chapter_verses/zephaniah"),
+    Haggai: require("./chapter_verses/haggai"),
+    Zechariah: require("./chapter_verses/zechariah"),
+    Malachi: require("./chapter_verses/malachi"),
+    Matthew: require("./chapter_verses/matthew"),
+    Mark: require("./chapter_verses/mark"),
+    Luke: require("./chapter_verses/luke"),
+    John: require("./chapter_verses/john"),
+    Acts: require("./chapter_verses/acts"),
+    Romans: require("./chapter_verses/romans"),
+    "1 Corinthians": require("./chapter_verses/1corinthians"),
+    "2 Corinthians": require("./chapter_verses/2corinthians"),
+    Galatians: require("./chapter_verses/galatians"),
+    Ephesians: require("./chapter_verses/ephesians"),
+    Philippians: require("./chapter_verses/philippians"),
+    Colossians: require("./chapter_verses/colossians"),
+    "1 Thessalonians": require("./chapter_verses/1thessalonians"),
+    "2 Thessalonians": require("./chapter_verses/2thessalonians"),
+    "1 Timothy": require("./chapter_verses/1timothy"),
+    "2 Timothy": require("./chapter_verses/2timothy"),
+    Titus: require("./chapter_verses/titus"),
+    Hebrews: require("./chapter_verses/hebrews"),
+    James: require("./chapter_verses/james"),
+    "1 Peter": require("./chapter_verses/1peter"),
+    "2 Peter": require("./chapter_verses/2peter"),
+    "1 John": require("./chapter_verses/1john"),
+    Revelation: require("./chapter_verses/revelation"),
+}