codexparser 0.0.81 → 0.0.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexparser",
-  "version": "0.0.81",
+  "version": "0.0.83",
   "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": {
@@ -31,4 +31,4 @@
     "bible-passage-reference-parser": "^2.0.1",
     "unidecode": "^1.1.0"
   }
-}
+}

package/src/CodexParser.js

@@ -1,13 +1,11 @@
+const versified = require("./versified")
 const bible = require("./bible")
 const { bookRegex, chapterRegex, verseRegex, scripturesRegex, EzraAbbrv } = require("./regex")
 const abbrevations = require("./abbr")
-//const toc = require("./toc")
 const crawler = require("bible-passage-reference-parser/js/en_bcv_parser").bcv_parser
 const util = require("util")
-
-const dump = (item) => {
-    console.log(util.inspect(item, { depth: null, colors: true }))
-}
+const dump = require("./functions").dump
+const dd = require("./functions").dd
 
 class CodexParser {
     constructor() {
@@ -22,35 +20,7 @@ class CodexParser {
         this.EzraAbbrv = EzraAbbrv
         //this.toc = toc
         this.crawler = new crawler()
-        this.preStrings = ["III", "II", "I", "1st", "2nd", "3rd", "First", "Second", "Third", "1", "2", "3"]
-        this.preStringed = [
-            "Sam",
-            "Samuel",
-            "Kings",
-            "Kgs",
-            "Kin",
-            "Chron",
-            "Chronicles",
-            "Corinthians",
-            "Co",
-            "Cor",
-            "Thessalonians",
-            "Th",
-            "Thes",
-            "Thess",
-            "Timothy",
-            "Ti",
-            "Tim",
-            "Peter",
-            "Pe",
-            "Pet",
-            "Pt",
-            "John",
-            "Jn",
-            "Jhn",
-        ]
-
-        this.text = String
+        this.versificationDifferences = versified
     }
 
     /**
@@ -112,7 +82,6 @@ class CodexParser {
      * @return {array} An array of parsed passages.
      */
     parse(reference) {
-        //TODO: Need to fix chapter ranges when another verse is tacted onto the end of it.
         if (!reference) {
             this.passages = []
             return this
@@ -136,6 +105,7 @@ class CodexParser {
                 chapter: result.start.c,
                 verses: this.versify(result),
                 type: result.type,
+                ...result["entities"][0],
             }
             passage.testament = this.bible.old.includes(passage.book) ? "old" : "new"
             let next = this.found[i + 1]
@@ -170,34 +140,66 @@ class CodexParser {
             passage.scripture = this.scripturize(passage)
             passage.passages = this.populate(result.entities[0], passage.verses)
             passage.indices = result.indices
-            passage.entities = result.entities[0]
-            if (passage.entities.translations) {
-                passage.version = {
-                    name: passage.entities.translations[0].translation,
-                    alias: passage.entities.translations[0].alias,
-                    abbreviation: passage.entities.translations[0].osis,
-                }
-            }
             this.passages.push(passage)
         }
         this.found = []
+        this.versification()
         return this
     }
 
+    versification() {
+        for (let i = 0; i < this.passages.length; i++) {
+            const passage = this.passages[i]
+            const hasVersification = this.versificationDifferences[passage.book]
+            for (let j = 0; j < passage.passages.length; j++) {
+                const subPassage = passage.passages[j]
+                if (hasVersification) {
+                    if (this.versificationDifferences[passage.book][subPassage.chapter + ":" + subPassage.verse])
+                        subPassage.versification =
+                            this.versificationDifferences[passage.book][subPassage.chapter + ":" + subPassage.verse]
+                }
+            }
+        }
+    }
+
+    /**
+     * Populate a Set of passages from entities.start.v to entities.end.v,
+     * and then add any additional verses from the verses array.
+     *
+     * @param {Object} entities - Entities object from the bible-passage-reference-parser
+     * @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: entities.start.b,
+                book: this.bookify(entities.start.b),
                 chapter: entities.start.c,
                 verse: i,
             })
         }
 
         if (verses.length > 1) {
+            const hasDashes = verses.find((verse) => verse.includes("-"))
+            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))
+                    }
+                }
+                verses = newVerses.sort((a, b) => a - b)
+            }
             for (let i = 0; i < verses.length; i++) {
                 const passage = {
-                    book: entities.start.b,
+                    book: this.bookify(entities.start.b),
                     chapter: entities.start.c,
                     verse: verses[i],
                 }
@@ -218,6 +220,14 @@ class CodexParser {
         return chapter.start.c
     }
 
+    /**
+     * 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") {
@@ -279,7 +289,10 @@ class CodexParser {
     }
 
     /**
-     * @param {object} passage - A passage object
+     * Converts a passage object into a scripturize object with human-readable name, chapter and verses and a hash.
+     *
+     * @param {object} passage - The passage object to scripturize.
+     * @return {object} The object with the human-readable name, chapter and verses and a hash.
      */
     scripturize(passage) {
         const { book, chapter, verses, to } = passage
@@ -288,198 +301,17 @@ class CodexParser {
         if (to) {
             parts.push("-", to.chapter, ":", to.verses)
         }
-        return parts
+        const full = parts
             .join(" ")
             .replace(/\s+:\s+/g, ":")
             .replace(/\s[-–—]\s/, "-")
             .trim()
-    }
-    find(text) {
-        const books = [...Object.keys(this.abbrevations), ...this.bible.new, ...this.bible.old]
-
-        let newText = ""
-
-        //add the prestringed versions e.g. 1 Peter
-        for (let b = 0; b < this.preStringed.length; b++) {
-            for (let pre = 0; pre < this.preStrings.length; pre++) {
-                books.push(this.preStrings[pre] + " " + this.preStringed[b])
-            }
-        }
-        // add the book name with . at the end as this seems to be added sometimes, at least to the shortened forms
-        const length = books.length
-        for (let b = 0; b < length; b++) {
-            books.push(books[b] + ".")
-        }
-
-        // sort descending - longer items first
-        books.sort((a, b) => b.length - a.length)
-        let booksAt = []
-        // go thro' each book finding where it matches in text
-        for (let b = 0; b < books.length; b++) {
-            const book = books[b]
-            let chNoInText = 0
-            while (chNoInText < text.length) {
-                let j = text.indexOf(book, chNoInText)
-                if (j < 0) break
-                if (j + book.length < text.length && !text.charAt(j + book.length).match(/^[a-z]+$/)) {
-                    booksAt.push([book, j])
-                    let replacement = book
-                    for (let k = 0; k < book.length; k++) {
-                        replacement = replacement.replace(book.charAt(k), "X")
-                    }
-                    text = text.replace(book, replacement) // to prevent a shorter version matching
-                }
-                chNoInText = j + book.length + 1
-            }
-        }
-        // into ascending order of start position
-        booksAt.sort(function (a, b) {
-            return a[1] - b[1]
-        })
-        newText = ""
-        let chNoInText = 0
-        for (let b = 0; b < booksAt.length; b++) {
-            while (chNoInText < booksAt[b][1]) {
-                //copy across characters to start of book
-                newText += text.charAt(chNoInText)
-                chNoInText++
-            }
-            newText += "<span class='passage'>" + booksAt[b][0]
-            let passage = booksAt[b][0]
-            chNoInText += booksAt[b][0].length //skip the 'fill-in characters
-            let abbr
-            let index = []
-            for (let i = 0; i < 100; i++) {
-                chNoInText++
-                let nextCh = text.charAt(chNoInText)
-                const testStr = text.substring(chNoInText - passage.length, chNoInText + 5).toLowerCase()
-                if (testStr.includes("lxx")) abbr = "lxx"
-                if (testStr.includes("na")) abbr = "na"
-                if (testStr.includes("ubs")) abbr = "ubs"
-                if (testStr.includes("mt")) abbr = "mt"
-                if (testStr.includes("bhs")) abbr = "bhs"
-                if (testStr.includes("lxx")) abbr = "lxx"
-                if (testStr.includes("na")) abbr = "na"
-                if (testStr.includes("ubs")) abbr = "ubs"
-                if (testStr.includes("mt")) abbr = "mt"
-                if (testStr.includes("bhs")) abbr = "bhs"
-                //test whether are at the end of the chapter(s) and verse(s)
-                if (nextCh.match(/^[a-z]+$/) && nextCh !== "f" && nextCh !== "ff" && nextCh !== "a") break
-                if (nextCh.match(/^[A-Z]+$/)) break
-                newText += text.charAt(chNoInText - 1)
-                passage += text.charAt(chNoInText - 1)
-                index.push(chNoInText - 1)
-            }
-
-            index = [index[0], index[index.length - 1]]
-            console.log(index)
-            this.found.push(passage.trim() + (abbr ? " " + abbr.toUpperCase() : ""))
-            newText += "</span>&nbsp;"
-        }
-        this.text = newText
-        return this
-    }
-
-    getText() {
-        return this.text
-    }
-
-    enhance() {
-        if (this.found.length > 0) {
-            for (let i = 0; i < this.found.length; i++) {
-                const found = this.found[i]
-                const book = this.bookify(this.found[i].match(this.bookRegex)[0])
-                const passageWithoutBook = found.replace(book, "")
-                let chapter, verse
-                if (/[:\.]/.test(passageWithoutBook)) {
-                    chapter = parseInt(passageWithoutBook.split(":").shift().trim(), 10)
-                    verse = parseInt(passageWithoutBook.split(":").pop().trim(), 10)
-                } else {
-                    if (/\d+/gim.test(passageWithoutBook)) {
-                        chapter = parseInt(passageWithoutBook.trim())
-                        verse = null
-                    }
-                }
-
-                let type = "verseRange"
-
-                const passage = {
-                    original: this.found[i],
-                    book: this.bookify(this.found[i].match(this.bookRegex)[0]),
-                    chapter: this.found[i].match(this.chapterRegex),
-                    verse: this.found[i].match(/(?<=[.:])(\d+.+)/)[0],
-                }
-                this.passages.push(passage)
-            }
+        const hash = full.toLowerCase().replace(/ /g, "_").replace(/:/g, ".").replace(/-/g, ".").replace(/,/g, ".")
+        return {
+            passage: full,
+            cv: chapter + colon + verses,
+            hash,
         }
-        return this.passages
-    }
-
-    regex(text) {
-        this.found = text.match(this.scripturesRegex)
-        return this
-    }
-
-    regexParser() {
-        this.passages = []
-        for (let i = 0; i < this.found.length; i++) {
-            let verse, chapter
-            const hasChapterRange = this.found[i].match(/(?<=-\s?)\b\d+[.:].+\b/)
-            const book = this.found[i].match(this.bookRegex)
-            if (book === null) continue
-            chapter = this.found[i].replace(book[0], "").match(this.chapterRegex)
-
-            if (Array.isArray(chapter)) {
-                chapter = chapter[0]
-            }
-            if (
-                this.bookify(book).toLowerCase() === "jude" ||
-                this.bookify(book).toLowerCase() === "philemon" ||
-                this.bookify(book).toLowerCase() === "obadiah" ||
-                this.bookify(book).toLowerCase() === "2 john" ||
-                this.bookify(book).toLowerCase() === "3 john"
-            ) {
-                verse = this.found[i].split(" ")[1]
-                chapter = "1"
-            } else {
-                if (this.found[i].match(this.verseRegex) && !hasChapterRange)
-                    verse = this.found[i].match(this.verseRegex)[0].replace(/[:.]/, "").trim()
-                else if (this.found[i].match(this.verseRegex) && hasChapterRange)
-                    verse = this.found[i].match(this.verseRegex)
-                        ? this.found[i].match(this.verseRegex)[0].split("-")[0].trim()
-                        : ["Empty"]
-            }
-            if (!verse && this.found[i].match(/\d+/)) {
-                chapter = this.found[i].match(/\d+/)[0]
-            }
-
-            const passage = {
-                original: this.found[i].replace(/([.,])\1*$/, "").trim(),
-                book: this.bookify(book),
-                chapter: chapter,
-                verses: verse ?? [],
-            }
-
-            if (hasChapterRange) {
-                passage.to = {
-                    book: passage.book,
-                    chapter: hasChapterRange[0].match(this.chapterRegex)[0],
-                    verses: hasChapterRange[0].match(this.verseRegex)[0],
-                }
-                passage.to.verses = passage.to.verses.split(/,/).filter(Boolean)
-                passage.to.testament = this.bible.old.includes(passage.to.book) ? "old" : "new"
-            }
-            passage.verses =
-                typeof passage.verses !== "object"
-                    ? passage.verses.split(/,/).filter(Boolean)
-                    : passage.verses.filter((item) => item.trim())
-            passage.testament = this.bible.old.includes(passage.book) ? "old" : "new"
-            passage.scripture = this.scripturize(passage)
-            this.passages.push(passage)
-        }
-
-        this.found = this.passages.map((passage) => passage.scripture)
-        return this
     }
 }
 

package/src/functions.js

@@ -3,4 +3,14 @@ const dump = (item) => {
     console.log(util.inspect(item, { depth: null, colors: true }))
 }
 
-module.exports.dump = dump
+function dd(message) {
+    dump(message)
+    // Optionally, you can also force the script to stop execution
+    // by throwing an error
+    process.exit(1)
+}
+
+module.exports = {
+    dump,
+    dd,
+}

package/src/versified.js

@@ -0,0 +1,623 @@
+const versified = {
+    Genesis: {
+        "31:55": {
+            lxx: "32:1",
+            mt: "31:55",
+            eng: "31:55",
+        },
+        "31:48": {
+            lxx: "31:47-48",
+            mt: "31:48",
+            eng: "31:48",
+        },
+        "31:52": {
+            lxx: "31:48",
+            mt: "31:52",
+            eng: "31:52",
+        },
+        "32:1": {
+            lxx: "32:2",
+            mt: "32:1",
+            eng: "32:1",
+        },
+        "32:2": {
+            lxx: "32:3",
+            mt: "32:2",
+            eng: "32:2",
+        },
+        "32:3": {
+            lxx: "32:4",
+            mt: "32:3",
+            eng: "32:3",
+        },
+        "32:4": {
+            lxx: "32:5",
+            mt: "32:4",
+            eng: "32:4",
+        },
+        "32:5": {
+            lxx: "32:6",
+            mt: "32:5",
+            eng: "32:5",
+        },
+        "32:6": {
+            lxx: "32:7",
+            mt: "32:6",
+            eng: "32:6",
+        },
+        "32:7": {
+            lxx: "32:8",
+            mt: "32:7",
+            eng: "32:7",
+        },
+        "32:8": {
+            lxx: "32:9",
+            mt: "32:8",
+            eng: "32:8",
+        },
+        "32:9": {
+            lxx: "32:10",
+            mt: "32:9",
+            eng: "32:9",
+        },
+        "32:10": {
+            lxx: "32:11",
+            mt: "32:10",
+            eng: "32:10",
+        },
+        "32:11": {
+            lxx: "32:12",
+            mt: "32:11",
+            eng: "32:11",
+        },
+        "32:12": {
+            lxx: "32:13",
+            mt: "32:12",
+            eng: "32:12",
+        },
+        "32:13": {
+            lxx: "32:14",
+            mt: "32:13",
+            eng: "32:13",
+        },
+        "32:14": {
+            lxx: "32:15",
+            mt: "32:14",
+            eng: "32:14",
+        },
+        "32:15": {
+            lxx: "32:16",
+            mt: "32:15",
+            eng: "32:15",
+        },
+        "32:16": {
+            lxx: "32:17",
+            mt: "32:16",
+            eng: "32:16",
+        },
+        "32:17": {
+            lxx: "32:18",
+            mt: "32:17",
+            eng: "32:17",
+        },
+        "32:18": {
+            lxx: "32:19",
+            mt: "32:18",
+            eng: "32:18",
+        },
+        "32:19": {
+            lxx: "32:20",
+            mt: "32:19",
+            eng: "32:19",
+        },
+        "32:20": {
+            lxx: "32:21",
+            mt: "32:20",
+            eng: "32:20",
+        },
+        "32:21": {
+            lxx: "32:22",
+            mt: "32:21",
+            eng: "32:21",
+        },
+        "32:22": {
+            lxx: "32:23",
+            mt: "32:22",
+            eng: "32:22",
+        },
+        "32:23": {
+            lxx: "32:24",
+            mt: "32:23",
+            eng: "32:23",
+        },
+        "32:24": {
+            lxx: "32:25",
+            mt: "32:24",
+            eng: "32:24",
+        },
+        "32:25": {
+            lxx: "32:26",
+            mt: "32:25",
+            eng: "32:25",
+        },
+        "32:26": {
+            lxx: "32:27",
+            mt: "32:26",
+            eng: "32:26",
+        },
+        "32:27": {
+            lxx: "32:28",
+            mt: "32:27",
+            eng: "32:27",
+        },
+        "32:28": {
+            lxx: "32:29",
+            mt: "32:28",
+            eng: "32:28",
+        },
+        "32:29": {
+            lxx: "32:30",
+            mt: "32:29",
+            eng: "32:29",
+        },
+        "32:30": {
+            lxx: "32:31",
+            mt: "32:30",
+            eng: "32:30",
+        },
+        "32:31": {
+            lxx: "32:32",
+            mt: "32:31",
+            eng: "32:31",
+        },
+        "32:32": {
+            lxx: "32:33",
+            mt: "32:32",
+            eng: "32:32",
+        },
+        "35:16": {
+            lxx: "35:16",
+            mt: "35:16",
+            eng: "35:16",
+        },
+        "35:21": {
+            lxx: "35:16",
+            mt: "35:21",
+            eng: "35:21",
+        },
+        "35:22": {
+            lxx: "35:21",
+            mt: "35:22",
+            eng: "35:22",
+        },
+    },
+    Exodus: {
+        "8:1": {
+            lxx: "8:1",
+            mt: "7:26",
+            eng: "8:1",
+        },
+        "8:2": {
+            lxx: "8:2",
+            mt: "7:27",
+            eng: "8:2",
+        },
+        "8:3": {
+            lxx: "8:3",
+            mt: "7:28",
+            eng: "8:3",
+        },
+        "8:4": {
+            lxx: "8:4",
+            mt: "7:29",
+            eng: "8:4",
+        },
+        "8:5": {
+            lxx: "8:5",
+            mt: "8:1",
+            eng: "8:5",
+        },
+        "8:6": {
+            lxx: "8:6",
+            mt: "8:2",
+            eng: "8:6",
+        },
+        "8:7": {
+            lxx: "8:7",
+            mt: "8:3",
+            eng: "8:7",
+        },
+        "8:8": {
+            lxx: "8:8",
+            mt: "8:4",
+            eng: "8:8",
+        },
+        "8:9": {
+            lxx: "8:9",
+            mt: "8:5",
+            eng: "8:9",
+        },
+        "8:10": {
+            lxx: "8:10",
+            mt: "8:6",
+            eng: "8:10",
+        },
+        "8:11": {
+            lxx: "8:11",
+            mt: "8:7",
+            eng: "8:11",
+        },
+        "8:12": {
+            lxx: "8:12",
+            mt: "8:8",
+            eng: "8:12",
+        },
+        "8:13": {
+            lxx: "8:13",
+            mt: "8:9",
+            eng: "8:13",
+        },
+        "8:14": {
+            lxx: "8:14",
+            mt: "8:10",
+            eng: "8:14",
+        },
+        "8:15": {
+            lxx: "8:15",
+            mt: "8:11",
+            eng: "8:15",
+        },
+        "8:16": {
+            lxx: "8:16",
+            mt: "8:12",
+            eng: "8:16",
+        },
+        "8:17": {
+            lxx: "8:17",
+            mt: "8:13",
+            eng: "8:17",
+        },
+        "8:18": {
+            lxx: "8:18",
+            mt: "8:14",
+            eng: "8:18",
+        },
+        "8:19": {
+            lxx: "8:19",
+            mt: "8:15",
+            eng: "8:19",
+        },
+        "8:20": {
+            lxx: "8:20",
+            mt: "8:16",
+            eng: "8:20",
+        },
+        "8:21": {
+            lxx: "8:21",
+            mt: "8:17",
+            eng: "8:21",
+        },
+        "8:22": {
+            lxx: "8:22",
+            mt: "8:18",
+            eng: "8:22",
+        },
+        "8:23": {
+            lxx: "8:23",
+            mt: "8:19",
+            eng: "8:23",
+        },
+        "8:24": {
+            lxx: "8:24",
+            mt: "8:20",
+            eng: "8:24",
+        },
+        "8:25": {
+            lxx: "8:25",
+            mt: "8:21",
+            eng: "8:25",
+        },
+        "8:26": {
+            lxx: "8:26",
+            mt: "8:22",
+            eng: "8:26",
+        },
+        "8:27": {
+            lxx: "8:27",
+            mt: "8:23",
+            eng: "8:27",
+        },
+        "8:28": {
+            lxx: "8:28",
+            mt: "8:24",
+            eng: "8:28",
+        },
+        "8:29": {
+            lxx: "8:29",
+            mt: "8:25",
+            eng: "8:29",
+        },
+        "8:30": {
+            lxx: "8:30",
+            mt: "8:26",
+            eng: "8:30",
+        },
+        "8:31": {
+            lxx: "8:31",
+            mt: "8:27",
+            eng: "8:31",
+        },
+        "8:32": {
+            lxx: "8:32",
+            mt: "8:28",
+            eng: "8:32",
+        },
+        "20:13": {
+            lxx: "20:13",
+            mt: "20:14",
+            eng: "20:13",
+        },
+        "20:14": {
+            lxx: "20:14",
+            mt: "20:15",
+            eng: "20:14",
+        },
+        "20:15": {
+            lxx: "20:15",
+            mt: "20:13",
+            eng: "20:15",
+        },
+        "22:1": {
+            lxx: "22:1",
+            mt: "21:37",
+            eng: "22:1",
+        },
+        "22:2": {
+            lxx: "22:2",
+            mt: "22:1",
+            eng: "22:2",
+        },
+        "22:3": {
+            lxx: "22:3",
+            mt: "22:2",
+            eng: "22:3",
+        },
+        "22:4": {
+            lxx: "22:4",
+            mt: "22:3",
+            eng: "22:4",
+        },
+        "22:5": {
+            lxx: "22:5",
+            mt: "22:4",
+            eng: "22:5",
+        },
+        "22:6": {
+            lxx: "22:6",
+            mt: "22:5",
+            eng: "22:6",
+        },
+        "22:7": {
+            lxx: "22:7",
+            mt: "22:6",
+            eng: "22:7",
+        },
+        "22:8": {
+            lxx: "22:8",
+            mt: "22:7",
+            eng: "22:8",
+        },
+        "22:9": {
+            lxx: "22:9",
+            mt: "22:8",
+            eng: "22:9",
+        },
+        "22:10": {
+            lxx: "22:10",
+            mt: "22:9",
+            eng: "22:10",
+        },
+        "22:11": {
+            lxx: "22:11",
+            mt: "22:10",
+            eng: "22:11",
+        },
+        "22:12": {
+            lxx: "22:12",
+            mt: "22:11",
+            eng: "22:12",
+        },
+        "22:13": {
+            lxx: "22:13",
+            mt: "22:12",
+            eng: "22:13",
+        },
+        "22:14": {
+            lxx: "22:14",
+            mt: "22:13",
+            eng: "22:14",
+        },
+        "22:15": {
+            lxx: "22:15",
+            mt: "22:14",
+            eng: "22:15",
+        },
+        "22:16": {
+            lxx: "22:16",
+            mt: "22:15",
+            eng: "22:16",
+        },
+        "22:17": {
+            lxx: "22:17",
+            mt: "22:16",
+            eng: "22:17",
+        },
+        "22:18": {
+            lxx: "22:18",
+            mt: "22:17",
+            eng: "22:18",
+        },
+        "22:19": {
+            lxx: "22:19",
+            mt: "22:18",
+            eng: "22:19",
+        },
+        "22:20": {
+            lxx: "22:20",
+            mt: "22:19",
+            eng: "22:20",
+        },
+        "22:21": {
+            lxx: "22:21",
+            mt: "22:20",
+            eng: "22:21",
+        },
+        "22:22": {
+            lxx: "22:22",
+            mt: "22:21",
+            eng: "22:22",
+        },
+        "22:23": {
+            lxx: "22:23",
+            mt: "22:22",
+            eng: "22:23",
+        },
+        "22:24": {
+            lxx: "22:24",
+            mt: "22:23",
+            eng: "22:24",
+        },
+        "22:25": {
+            lxx: "22:25",
+            mt: "22:24",
+            eng: "22:25",
+        },
+        "22:26": {
+            lxx: "22:26",
+            mt: "22:25",
+            eng: "22:26",
+        },
+        "22:27": {
+            lxx: "22:27",
+            mt: "22:26",
+            eng: "22:27",
+        },
+        "22:28": {
+            lxx: "22:28",
+            mt: "22:27",
+            eng: "22:28",
+        },
+        "22:29": {
+            lxx: "22:29",
+            mt: "22:28",
+            eng: "22:29",
+        },
+        "22:30": {
+            lxx: "22:30",
+            mt: "22:29",
+            eng: "22:30",
+        },
+        "22:31": {
+            lxx: "22:31",
+            mt: "22:30",
+            eng: "22:31",
+        },
+        "35:9": {
+            lxx: "35:8",
+            mt: "35:9",
+            eng: "35:9",
+        },
+        "35:10": {
+            lxx: "35:9",
+            mt: "35:10",
+            eng: "35:10",
+        },
+        "35:11": {
+            lxx: "35:10",
+            mt: "35:11",
+            eng: "35:11",
+        },
+        "35:12": {
+            lxx: "35:11",
+            mt: "35:12",
+            eng: "35:12",
+        },
+        "35:17": {
+            lxx: "35:12",
+            mt: "35:17",
+            eng: "35:17",
+        },
+        "35:13": {
+            lxx: "35:15",
+            mt: "35:13",
+            eng: "35:13",
+        },
+        "35:14": {
+            lxx: "35:16",
+            mt: "35:14",
+            eng: "35:14",
+        },
+        "35:16": {
+            lxx: "35:17",
+            mt: "35:16",
+            eng: "35:16",
+        },
+        "35:19": {
+            lxx: "35:18",
+            mt: "35:19",
+            eng: "35:19",
+        },
+        "35:15": {
+            lxx: "35:19",
+            mt: "35:15",
+            eng: "35:15",
+        },
+        "36:8": {
+            lxx: "37:1",
+            mt: "36:8",
+            eng: "36:8",
+        },
+        "36:9": {
+            lxx: "37:2",
+            mt: "36:9",
+            eng: "36:9",
+        },
+        "36:35": {
+            lxx: "37:3",
+            mt: "36:35",
+            eng: "36:35",
+        },
+        "36:36": {
+            lxx: "37:4",
+            mt: "36:36",
+            eng: "36:36",
+        },
+        "36:37": {
+            lxx: "37:5",
+            mt: "36:37",
+            eng: "36:37",
+        },
+        "36:38": {
+            lxx: "37:6",
+            mt: "36:38",
+            eng: "36:38",
+        },
+    },
+    Psalms: {
+        "23:1": {
+            lxx: "22:1",
+            mt: "23:1",
+            eng: "23:1",
+        },
+    },
+    "1 Samuel": {
+        "20:42": {
+            lxx: "20:41",
+            mt: "20:42",
+            eng: "20:42",
+        },
+    },
+    // Add more books and verses as needed
+}
+
+module.exports = versified

package/tests/single.js

@@ -3,7 +3,7 @@ const dump = require("../src/functions.js").dump
 
 const parser = new BibleParser()
 
-const text = "Job 1:1-5"
+const text = "Genesis 22:1-2,14,19"
 
 const passages = parser.parse(text).getPassages()
 

package/tests/versification.js

@@ -0,0 +1,8 @@
+const BibleParser = require("../src/CodexParser")
+const dump = require("../src/functions").dump
+
+const parser = new BibleParser()
+
+const passages = parser.parse("Exodus 8:1").getPassages()
+
+dump(passages)