codexparser 0.3.1 → 0.4.0

package/src/CodexParser.js.backup

@@ -1,1713 +0,0 @@
-/**
- * CodexParser.js
- * A modern ES6+ class for scanning and parsing scripture references from text.
- * Supports various formats (single verses, ranges, multi-chapter references) with 
- * validation and version-specific versification.
- */
-
-const bible = require("./bible");
-const { bookRegex, chapterRegex, verseRegex, scripturesRegex } = require("./regex");
-const ScriptureScanner = require("./ScriptureScanner");
-const ReferenceParser = require("./ReferenceParser");
-const VersificationHandler = require("./VersificationHandler");
-const PassageCollection = require("./PassageCollection");
-const PassageUtils = require("./PassageUtils");
-const VersionHandler = require("./VersionHandler");
-const chapter_verses = require("./chapterVerseCombine");
-
-/**
- * Main class for parsing and validating scripture references
- * @class
- */
-class CodexParser {
-    // Private fields using ES6+ syntax
-    #scanner;
-    #parser;
-    #versificationHandler;
-    #config;
-    #version;
-    #found;
-    #passages;
-
-    /**
-     * Initializes the parser with configuration
-     * @param {Object} config - Configuration options
-     */
-    constructor(config = {}) {
-        this.#config = {
-            booksOnly: config.booksOnly ?? false,
-            invalid_sequence_strategy: config.invalid_sequence_strategy ?? "include",
-            invalid_passage_strategy: config.invalid_passage_strategy ?? "include",
-        };
-
-        this.#scanner = new ScriptureScanner(this.#config);
-        this.#parser = new ReferenceParser(this.#config);
-        this.#versificationHandler = new VersificationHandler();
-        this.#version = null;
-        this.#found = [];
-        this.#passages = [];
-
-        // Legacy public properties for backward compatibility
-        this.bible = bible;
-        this.bookRegex = bookRegex;
-        this.chapterRegex = chapterRegex;
-        this.verseRegex = verseRegex;
-        this.scripturesRegex = scripturesRegex;
-        this.chapterVerses = chapter_verses;
-        this.error = false;
-        
-        // Legacy constants
-        this.SINGLE_CHAPTER = "single_chapter";
-        this.CHAPTER_VERSE = "chapter_verse";
-        this.CHAPTER_VERSE_RANGE = "chapter_verse_range";
-        this.COMMA_SEPARATED = "comma_separated_verses";
-        this.CHAPTER_RANGE = "chapter_range";
-        this.MULTI_CHAPTER_RANGE = "multi_chapter_verse_range";
-    }
-
-    /**
-     * Gets the found references (legacy getter)
-     */
-    get found() {
-        return this.#found;
-    }
-
-    /**
-     * Sets the found references (legacy setter)
-     */
-    set found(value) {
-        this.#found = value;
-    }
-
-    /**
-     * Gets the parsed passages (legacy getter)
-     */
-    get passages() {
-        return this.#passages;
-    }
-
-    /**
-     * Sets the parsed passages (legacy setter)
-     */
-    set passages(value) {
-        this.#passages = value;
-    }
-
-    /**
-     * Gets the current version (legacy getter)
-     */
-    get version() {
-        return this.#version;
-    }
-
-    /**
-     * Sets the current version (legacy setter)
-     */
-    set version(value) {
-        this.#version = value;
-    }
-
-    /**
-     * Gets the current config (legacy getter)
-     */
-    get config() {
-        return this.#config;
-    }
-
-    /**
-     * Sets the current config (legacy setter)
-     */
-    set config(value) {
-        this.#config = value;
-    }
-
-    /**
-     * Sets configuration options for the parser
-     * @param {Object} config - Configuration options
-     * @param {boolean} [config.booksOnly=false] - Whether to capture book names without references
-     * @returns {CodexParser} The parser instance for method chaining
-     */
-    options(config) {
-        this.#config = {
-            booksOnly: config.booksOnly ?? this.#config.booksOnly,
-            invalid_sequence_strategy: config.invalid_sequence_strategy ?? this.#config.invalid_sequence_strategy,
-            invalid_passage_strategy: config.invalid_passage_strategy ?? this.#config.invalid_passage_strategy,
-        };
-        
-        // Update scanner and parser configs
-        this.#scanner = new ScriptureScanner(this.#config);
-        this.#parser = new ReferenceParser(this.#config);
-        
-        return this;
-    }
-
-    /**
-     * Retrieves available verses for a given book and chapter (legacy method)
-     * @param {string} book - The book name
-     * @param {number} chapter - The chapter number
-     * @returns {number[]} Array of valid verse numbers
-     */
-    getChapterVerses(book, chapter) {
-        return PassageUtils.getChapterVerses(book, chapter);
-    }
-
-    /**
-     * Scans text for scripture references
-     * @param {string} text - The text to scan
-     * @returns {CodexParser} The parser instance for method chaining
-     */
-    scan(text) {
-        this.#found = this.#scanner.scan(text);
-        return this;
-    }
-
-    /**
-     * Sets the Bible version for parsing
-     * @param {string} version - The version (e.g., "lxx", "mt", "eng")
-     * @returns {CodexParser} The parser instance
-     */
-    bibleVersion(version) {
-        this.#version = VersionHandler.normalizeVersion(version);
-        return this;
-    }
-
-    /**
-     * Parses a scripture reference into structured passage objects
-     * @param {string} reference - The reference to parse (e.g., "John 3:16")
-     * @returns {CodexParser} The parser instance
-     */
-    parse(reference) {
-        this.scan(reference);
-        this.#passages = this.#parser.parse(this.#found, this.#version);
-        this.#passages = this.#versificationHandler.applyVersification(this.#passages);
-        return this;
-    }
-
-    /**
-     * Returns parsed passages with utility methods
-     * @returns {PassageCollection} Collection of passages with utility methods
-     */
-    getPassages() {
-        return PassageCollection.from(this.#passages);
-    }
-
-    /**
-     * Returns the first parsed passage
-     * @returns {Object|null} The first passage or null
-     */
-    first() {
-        return this.#passages.length > 0 ? this.#passages[0] : null;
-    }
-
-    /**
-     * Normalizes book names using abbreviations or full names (legacy method)
-     * @param {string|Array} book - The book name or array
-     * @returns {string} Normalized book name
-     */
-    bookify(book) {
-        return this.#parser.constructor.prototype.normalizeBookName?.(book) || book;
-    }
-
-    /**
-     * Combines multiple passages into a single reference
-     * @param {Object[]} [passages=this.passages] - Array of passages to combine
-     * @returns {Object} Combined passage object
-     */
-    combine(passages = this.#passages) {
-        return PassageCollection.combinePassages(passages);
-    }
-
-    /**
-     * Merges verses into ranges or comma-separated lists (legacy method)
-     * @param {number[]} verses - Array of verse numbers
-     * @returns {string[]} Array of verse strings
-     */
-    mergeRanges(verses) {
-        return PassageUtils.mergeRanges(verses);
-    }
-
-    /**
-     * Generates a table of contents for the Bible
-     * @param {string} [version="ESV"] - The Bible version
-     * @returns {Object} TOC with book-chapter-verse mappings
-     */
-    getToc(version = "ESV") {
-        const toc = {};
-        
-        bible.old.forEach((book) => {
-            if (chapter_verses[book]) {
-                toc[book] = chapter_verses[book];
-            }
-        });
-        
-        bible.new.forEach((book) => {
-            if (chapter_verses[book]) {
-                toc[book] = chapter_verses[book];
-            }
-        });
-        
-        PassageUtils.SINGLE_CHAPTER_BOOKS.forEach((item) => {
-            Object.keys(item).forEach((book) => {
-                if (!toc[book]) {
-                    toc[book] = item[book];
-                }
-            });
-        });
-        
-        const orderedToc = {};
-        const canonicalOrder = [...bible.old, ...bible.new];
-        canonicalOrder.forEach((book) => {
-            if (toc[book]) {
-                orderedToc[book] = toc[book];
-            }
-        });
-        
-        return orderedToc;
-    }
-
-    /**
-     * Replaces scripture references in text with formatted references
-     * @param {string} text - The original text
-     * @param {boolean} useAbbreviations - Whether to use abbreviated book names
-     * @returns {string} Text with replaced references
-     */
-    replace(text, useAbbreviations = true) {
-        if (!this.#passages.length) {
-            return text;
-        }
-
-        let result = text;
-        for (let i = this.#passages.length - 1; i >= 0; i--) {
-            const passage = this.#passages[i];
-            const { originalText, abbr, original } = passage;
-            const newReference = useAbbreviations ? abbr : original;
-
-            const regex = new RegExp(`${originalText.replace(/([.*+?^${}()|[\]\\])/g, "\\$1")}`, "g");
-
-            const matches = [...result.matchAll(regex)];
-            if (matches.length > 0) {
-                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] || "";
-                    const hasOpeningParen = match[2] === "(";
-                    const hasClosingParen = match[3] === ")";
-                    const trailingSpace = match[4] || " ";
-                    const replacement =
-                        hasOpeningParen && hasClosingParen
-                            ? `${leadingSpace}(${newReference})${trailingSpace}`
-                            : `${leadingSpace}${newReference}${trailingSpace}`;
-                    result = result.slice(0, startIndex) + replacement + result.slice(endIndex);
-                }
-            }
-        }
-
-        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
-     */
-    same() {
-        if (this.#passages.length <= 1) {
-            return true;
-        }
-
-        const firstBook = this.#passages[0].book.toLowerCase();
-        return this.#passages.every((passage) => passage.book.toLowerCase() === firstBook);
-    }
-
-    // Legacy methods for backward compatibility
-    
-    /**
-     * Expands verse references into individual verse objects (legacy)
-     */
-    expandVerses(book, chapter, verses) {
-        return PassageUtils.expandVerses(book, chapter, verses);
-    }
-
-    /**
-     * Populates passage with expanded verse objects (legacy)
-     */
-    populate(passage) {
-        return this.#parser.constructor.prototype._populatePassage?.(passage) || [];
-    }
-
-    /**
-     * Formats a passage into a human-readable reference (legacy)
-     */
-    scripturize(passage) {
-        return this.#parser.constructor.prototype._formatScripture?.(passage) || {};
-    }
-
-    /**
-     * Applies versification differences to parsed passages (legacy)
-     */
-    versification() {
-        this.#passages = this.#versificationHandler.applyVersification(this.#passages);
-    }
-}
-
-module.exports = CodexParser;
-
-
-
-                testament,
-                startIndex: passage.startIndex,
-                endIndex: passage.endIndex,
-                originalText: passage.originalText,
-                version: this._handleVersion(passage.version, testament),
-                passages: [],
-                scripture: null,
-                valid: true,
-                start: null,
-                end: null,
-                abbr: null,
-            }
-
-            // Clean reference for parsing
-            let cleanReference = passage.reference.replace(/\s*(LXX|MT)$/i, "").trim()
-            if (cleanReference.endsWith(",")) {
-                cleanReference = cleanReference.slice(0, -1).trim()
-            }
-
-            // 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
-                parsedPassage.type = this.SINGLE_CHAPTER
-                const chapterVerses = this.getChapterVerses(book, chapter)
-                if (chapterVerses.length) {
-                    const startVerse = chapterVerses[0]
-                    const endVerse = chapterVerses[chapterVerses.length - 1]
-                    parsedPassage.verses = [`${startVerse}-${endVerse}`]
-                }
-            } else 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())
-            } else {
-                this.parseReferenceParts(parsedPassage, cleanReference)
-            }
-
-            parsedPassage.passages = this.populate(parsedPassage)
-            parsedPassage.scripture = this.scripturize(parsedPassage)
-            parsedPassage.valid = this._isValid(parsedPassage, cleanReference)
-
-            // Set abbr property using SBL-style abbreviations
-            const sblEntry = Object.entries(this.sblAbbreviations).find(
-                ([key]) => key.toLowerCase() === book.toLowerCase()
-            )
-            if (sblEntry) {
-                const { value, abbr } = sblEntry[1]
-                const ref = passage.reference.replace(/\s*(LXX|MT)$/i, "").trim()
-                parsedPassage.abbr = abbr
-                    ? `${value}. ${ref}${
-                          parsedPassage.version.value !== "ENG" ? " " + parsedPassage.version.value : ""
-                      }`
-                    : `${value} ${ref}${parsedPassage.version.value !== "ENG" ? " " + parsedPassage.version.value : ""}`
-            } else {
-                parsedPassage.abbr = parsedPassage.original
-            }
-
-            if (parsedPassage.type === this.MULTI_CHAPTER_RANGE) {
-                this.handleMultiChapterRange(parsedPassage, cleanReference)
-            } else {
-                delete parsedPassage.to
-            }
-
-            // Calculate start and end based on passages array
-            if (parsedPassage.passages.length > 0) {
-                const sortedPassages = parsedPassage.passages.slice().sort((a, b) => {
-                    if (a.chapter !== b.chapter) return a.chapter - b.chapter
-                    return a.verse - b.verse
-                })
-                const firstPassage = sortedPassages[0]
-                const lastPassage = sortedPassages[sortedPassages.length - 1]
-                parsedPassage.start = {
-                    book: firstPassage.book,
-                    chapter: firstPassage.chapter,
-                    verse: firstPassage.verse,
-                }
-                parsedPassage.end = {
-                    book: lastPassage.book,
-                    chapter: lastPassage.chapter,
-                    verse: lastPassage.verse,
-                }
-            }
-
-            if (!parsedPassage.version) {
-                parsedPassage.version = {
-                    name: "English",
-                    value: "ENG",
-                    abbreviation: "eng",
-                }
-            }
-
-            return parsedPassage
-        })
-
-        this.versification()
-        return this
-    }
-    /**
-     * Parses reference parts into chapter and verse components.
-     * @param {Object} passage - The passage object to populate.
-     * @param {string} reference - The reference string.
-     * @private
-     */
-    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) => {
-            const isFirstPart = index === 0
-
-            // 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, ""))
-                if (chapter > 0) {
-                    passage.chapter = chapter
-                    passage.type = this.SINGLE_CHAPTER
-                    const chapterVerses = this.getChapterVerses(passage.book, chapter)
-                    if (chapterVerses.length) {
-                        const startVerse = chapterVerses[0]
-                        const endVerse = chapterVerses[chapterVerses.length - 1]
-                        passage.verses = [`${startVerse}-${endVerse}`]
-                    }
-                    return
-                }
-            }
-
-            if (part.includes(":")) {
-                this.parseChapterVerse(passage, part, isFirstPart)
-            } else if (singleChapterBook) {
-                this.parseSingleChapterBook(passage, part, isFirstPart && parts.length === 1)
-            } else if (part.includes("-")) {
-                this.parseRange(passage, part, isFirstPart)
-            } else {
-                this.parseSingleNumber(passage, part, isFirstPart)
-            }
-        })
-    }
-
-    /**
-     * Parses chapter-verse references (e.g., "3:16").
-     * @param {Object} passage - The passage object.
-     * @param {string} part - The reference part.
-     * @param {boolean} isFirstPart - Whether this is the first part.
-     * @private
-     */
-    parseChapterVerse(passage, part, isFirstPart) {
-        const [chapter, verse] = part.split(/[:.]/).map((s) => s.trim())
-        if (isFirstPart) passage.chapter = Number(chapter)
-        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)
-        }
-    }
-
-    /**
-     * Parses references for single-chapter books (e.g., "Jude 5").
-     * @param {Object} passage - The passage object.
-     * @param {string} part - The reference part.
-     * @param {boolean} isWholeChapter - Whether the reference is for the whole chapter.
-     * @private
-     */
-    parseSingleChapterBook(passage, part, isWholeChapter) {
-        const verseCount = this.getChapterVerses(passage.book, 1).length
-        if (part === "1" && isWholeChapter) {
-            passage.chapter = 1
-            passage.type = this.SINGLE_CHAPTER
-            passage.verses = [`1-${verseCount}`]
-        } else if (part.includes("-")) {
-            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 > 0) {
-                passage.chapter = 1
-                passage.verses.push(num)
-                passage.type = this.CHAPTER_VERSE
-            }
-        }
-    }
-
-    /**
-     * Parses range references (e.g., "1-3").
-     * @param {Object} passage - The passage object.
-     * @param {string} part - The reference part.
-     * @param {boolean} isFirstPart - Whether this is the first part.
-     * @private
-     */
-    parseRange(passage, part, isFirstPart) {
-        if (!passage.chapter && isFirstPart) {
-            const [start, end] = part.split("-").map(Number)
-            passage.chapter = start
-            const startVerses = this.getChapterVerses(passage.book, start)
-            passage.verses = [`${startVerses[0]}-${startVerses[startVerses.length - 1]}`]
-            passage.to = {
-                book: passage.book,
-                chapter: end,
-                verses: [
-                    `${this.getChapterVerses(passage.book, end)[0]}-${
-                        this.getChapterVerses(passage.book, end).slice(-1)[0]
-                    }`,
-                ],
-            }
-            passage.type = this.CHAPTER_RANGE
-        } else {
-            passage.verses.push(part)
-            passage.type = this.CHAPTER_VERSE_RANGE
-        }
-    }
-
-    /**
-     * Parses single number references (e.g., "3" for chapter or verse).
-     * @param {Object} passage - The passage object.
-     * @param {string} part - The reference part.
-     * @param {boolean} isFirstPart - Whether this is the first part.
-     * @private
-     */
-    parseSingleNumber(passage, part, isFirstPart) {
-        if (isFirstPart && !passage.chapter) {
-            passage.chapter = Number(part)
-            passage.type = this.SINGLE_CHAPTER
-            const chapterVerses = this.getChapterVerses(passage.book, passage.chapter)
-            if (chapterVerses.length) {
-                passage.verses = [`${chapterVerses[0]}-${chapterVerses[chapterVerses.length - 1]}`]
-            }
-        } else {
-            passage.verses.push(Number(part))
-            passage.type = this.COMMA_SEPARATED
-        }
-    }
-
-    /**
-     * Handles multi-chapter range references (e.g., "3:16-4:5").
-     * @param {Object} passage - The passage object.
-     * @param {string} reference - The full reference string.
-     * @private
-     */
-    handleMultiChapterRange(passage, reference) {
-        const parts = reference.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 ? [endVerse] : ["1"],
-            }
-        }
-    }
-
-    /**
-     * Generates a range of numbers.
-     * @param {number} start - Start number.
-     * @param {number} end - End number.
-     * @returns {number[]} Array of numbers.
-     * @private
-     */
-    _generateRange(start, end) {
-        const range = []
-        for (let i = start; i <= end; i++) {
-            range.push(i)
-        }
-        return range
-    }
-
-    /**
-     * Searches for versification differences for a book and chapter.
-     * @param {string} book - The book name.
-     * @param {number} chapter - The chapter number.
-     * @param {string} version - The Bible version.
-     * @returns {Object|undefined} Updated chapter verses or undefined.
-     * @private
-     */
-    _searchVersificationDifferences(book, chapter, version) {
-        version = version.toLowerCase()
-
-        // Handle single-chapter book "Obadiah"
-        if (book === "Obadiah") {
-            const singleChapterBook = this.singleChapterBook.find((b) => Object.keys(b)[0] === "Obadiah")
-            if (!singleChapterBook || !singleChapterBook[book][chapter]) {
-                return // No data for Obadiah or chapter
-            }
-            if (!this.versificationDifferences[book]) {
-                return // No versification differences for Obadiah
-            }
-            // Process versification differences
-            for (const [key, value] of Object.entries(this.versificationDifferences[book])) {
-                if (value[version].startsWith(`${chapter}:`)) {
-                    if (value[version]) {
-                        const verse = value[version].split(":")[1]
-                        singleChapterBook[book][chapter].push(Number(verse))
-                    }
-                }
-            }
-            singleChapterBook[book][chapter] = Array.from(new Set(singleChapterBook[book][chapter]))
-            return singleChapterBook[book]
-        }
-
-        // Handle all other books using chapterVerses
-        if (!this.chapterVerses[book][chapter]) {
-            return
-        }
-        if (!this.versificationDifferences[book]) {
-            return
-        }
-        for (const [key, value] of Object.entries(this.versificationDifferences[book])) {
-            if (value[version].startsWith(`${chapter}:`)) {
-                if (value[version]) {
-                    const verse = value[version].split(":")[1]
-                    this.chapterVerses[book][chapter].push(Number(verse))
-                }
-            }
-        }
-        this.chapterVerses[book][chapter] = Array.from(new Set(this.chapterVerses[book][chapter]))
-        return this.chapterVerses
-    }
-
-    /**
-     * Sets the Bible version and applies versification differences.
-     * @param {string} book - The book name.
-     * @param {number} chapter - The chapter number.
-     * @param {string} version - The Bible version.
-     * @private
-     */
-    _setVersion(book, chapter, version) {
-        this.version = version ? version : "eng"
-        if (this.version !== "eng") {
-            this._searchVersificationDifferences(book, chapter, version)
-        }
-    }
-
-    /**
-     * Applies versification differences to parsed passages.
-     */
-    versification() {
-        this.passages.forEach((passage) => {
-            const hasVersification = this.versificationDifferences[passage.book]
-            passage.passages.forEach((subPassage) => {
-                if (hasVersification) {
-                    const key = `${subPassage.chapter}:${subPassage.verse}`
-                    if (this.versificationDifferences[passage.book][key]) {
-                        subPassage.versification = this.versificationDifferences[passage.book][key]
-                    }
-                }
-                if (passage.version) {
-                    const versionAbbreviation = passage.version.abbreviation
-                    const versionType =
-                        versionAbbreviation === "lxx" ? "lxx" : versionAbbreviation === "mt" ? "mt" : null
-                    if (versionType) {
-                        const versionReference = `${subPassage.chapter}:${subPassage.verse}`
-                        for (const versification in this.versificationDifferences[passage.book]) {
-                            if (
-                                this.versificationDifferences[passage.book][versification][versionType] ===
-                                versionReference
-                            ) {
-                                subPassage.versification = this.versificationDifferences[passage.book][versification]
-                                break
-                            }
-                        }
-                    }
-                }
-            })
-        })
-    }
-
-    /**
-     * Populates passage with expanded verse objects.
-     * @param {Object} passage - The passage object.
-     * @returns {Object[]} Array of verse objects.
-     */
-    populate(passage) {
-        const { book, chapter, verses, type, to } = passage
-        const version = passage.version?.abbreviation || "eng"
-        this._setVersion(book, chapter, version)
-
-        if (type === this.SINGLE_CHAPTER) {
-            const chapterVerses = this.getChapterVerses(book, chapter)
-            return this.expandVerses(book, chapter, [`${chapterVerses[0]}-${chapterVerses[chapterVerses.length - 1]}`])
-        }
-
-        if (type === this.CHAPTER_VERSE || type === this.COMMA_SEPARATED || type === this.CHAPTER_VERSE_RANGE) {
-            return this.expandVerses(book, chapter, verses)
-        }
-
-        if (type === this.CHAPTER_RANGE) {
-            const passages = []
-            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]) || 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 <= endChapter; ch++) {
-                const chapterVerses = this.getChapterVerses(book, ch)
-                const from = ch === chapter ? startVerse : chapterVerses[0]
-                const toVerse = ch === endChapter ? endVerse : chapterVerses[chapterVerses.length - 1]
-                passages.push(...this.expandVerses(book, ch, [`${from}-${toVerse}`]))
-            }
-            return passages
-        }
-
-        return []
-    }
-
-    /**
-     * Expands verse references into individual verse objects.
-     * @param {string} book - The book name.
-     * @param {number} chapter - The chapter number.
-     * @param {Array<string|number>} verses - Array of verses or ranges.
-     * @returns {Object[]} Array of verse objects.
-     */
-    expandVerses(book, chapter, verses) {
-        const passages = []
-        const chapterVerses = this.getChapterVerses(book, chapter)
-
-        verses.forEach((verse) => {
-            if (typeof verse === "string" && verse.includes("-")) {
-                const [start, end] = verse.split("-").map(Number)
-                for (let i = start; i <= end && i <= chapterVerses[chapterVerses.length - 1]; i++) {
-                    passages.push({ book, chapter, verse: i })
-                }
-            } else {
-                const verseNum = Number(verse)
-                if (!isNaN(verseNum) && verseNum > 0) {
-                    passages.push({ book, chapter, verse: verseNum })
-                }
-            }
-        })
-        return passages
-    }
-
-    /**
-     * Normalizes book names using abbreviations or full names.
-     * @param {string|Array} book - The book name or array.
-     * @returns {string} Normalized book name.
-     */
-    bookify(book) {
-        if (typeof book !== "string") {
-            book = book[0]
-        }
-        book = book.toLowerCase()
-        let bookified = this.abbreviations[Object.keys(this.abbreviations).find((abbr) => abbr.toLowerCase() === book)]
-        if (bookified) {
-            return bookified
-        }
-        bookified =
-            this.bible.new.find((b) => b.toLowerCase() === book) || this.bible.old.find((b) => b.toLowerCase() === book)
-        return bookified || book
-    }
-
-    /**
-     * Returns parsed passages with utility methods.
-     * @returns {Object[]} Array of passages with methods.
-     */
-    getPassages() {
-        const passagesArray = [...this.passages]
-        const self = this
-
-        passagesArray.first = function () {
-            return this.length > 0 ? this[0] : null
-        }
-
-        passagesArray.oldTestament = function () {
-            return this.filter((passage) => passage.testament === "old")
-        }
-
-        passagesArray.newTestament = function () {
-            return this.filter((passage) => passage.testament === "new")
-        }
-
-        passagesArray.combine = function (options = {}) {
-            const { book = true, chapter = true } = options
-
-            if (!book) {
-                return [...this]
-            }
-
-            const groupedByBook = new Map()
-
-            this.forEach((passage) => {
-                const bookKey = passage.book
-                if (!groupedByBook.has(bookKey)) {
-                    groupedByBook.set(bookKey, [])
-                }
-                groupedByBook.get(bookKey).push(passage)
-            })
-
-            const combinedPassages = []
-
-            for (const [book, bookPassages] of groupedByBook) {
-                if (chapter) {
-                    const groupedByChapter = new Map()
-                    bookPassages.forEach((passage) => {
-                        const chapterKey = `${passage.book}-${passage.chapter}`
-                        if (!groupedByChapter.has(chapterKey)) {
-                            groupedByChapter.set(chapterKey, [])
-                        }
-                        groupedByChapter.get(chapterKey).push(passage)
-                    })
-
-                    for (const passages of groupedByChapter.values()) {
-                        if (passages.length === 1) {
-                            combinedPassages.push({ ...passages[0] })
-                        } else {
-                            const combined = self.combine(passages)
-                            combinedPassages.push(combined)
-                        }
-                    }
-                } else {
-                    const combined = self.combine(bookPassages)
-                    combinedPassages.push(combined)
-                }
-            }
-
-            return combinedPassages
-        }
-
-        passagesArray.getVersion = function (targetVersion) {
-            const targetAbbr = targetVersion.toLowerCase() === "bhs" ? "mt" : targetVersion.toLowerCase()
-            let versionObj
-            if (targetAbbr === "eng") {
-                versionObj = { name: "English", value: "ENG", abbreviation: "eng" }
-            } else if (targetAbbr === "mt") {
-                versionObj = { name: "Masoretic Text", value: "MT", abbreviation: "mt" }
-            } else if (targetAbbr === "lxx") {
-                versionObj = { name: "Septuagint", value: "LXX", abbreviation: "lxx" }
-            } else {
-                throw new Error("Invalid version: must be one of 'eng', 'mt', 'bhs', 'lxx'")
-            }
-
-            const converted = this.map((passage) => {
-                const cloned = JSON.parse(JSON.stringify(passage))
-                cloned.version = versionObj
-
-                cloned.passages.forEach((sub) => {
-                    if (sub.versification && sub.versification[targetAbbr]) {
-                        const [ch, v] = sub.versification[targetAbbr].split(":").map(Number)
-                        sub.chapter = ch
-                        sub.verse = v
-                    }
-                    // else remain unchanged
-                })
-
-                // Recompute summary fields
-                cloned.passages.sort((a, b) => a.chapter - b.chapter || a.verse - b.verse)
-
-                if (cloned.passages.length > 0) {
-                    cloned.start = {
-                        book: cloned.book,
-                        chapter: cloned.passages[0].chapter,
-                        verse: cloned.passages[0].verse,
-                    }
-                    cloned.end = {
-                        book: cloned.book,
-                        chapter: cloned.passages[cloned.passages.length - 1].chapter,
-                        verse: cloned.passages[cloned.passages.length - 1].verse,
-                    }
-                }
-
-                const chapterVersesMap = {}
-                cloned.passages.forEach((p) => {
-                    if (!chapterVersesMap[p.chapter]) chapterVersesMap[p.chapter] = new Set()
-                    chapterVersesMap[p.chapter].add(p.verse)
-                })
-
-                const sortedChs = Object.keys(chapterVersesMap)
-                    .map(Number)
-                    .sort((a, b) => a - b)
-                const chapterStrs = []
-
-                const mergeFunc = (verses) => {
-                    const sorted = [...verses].sort((a, b) => a - b)
-                    const merged = []
-                    if (sorted.length === 0) return merged
-                    let start = sorted[0]
-                    let end = sorted[0]
-                    for (let i = 1; i < sorted.length; i++) {
-                        if (sorted[i] === end + 1) {
-                            end = sorted[i]
-                        } else {
-                            merged.push(start === end ? `${start}` : `${start}-${end}`)
-                            start = end = sorted[i]
-                        }
-                    }
-                    merged.push(start === end ? `${start}` : `${start}-${end}`)
-                    return merged
-                }
-
-                sortedChs.forEach((ch) => {
-                    const vs = Array.from(chapterVersesMap[ch])
-                        .filter((v) => v > 0)
-                        .sort((a, b) => a - b)
-                    if (vs.length > 0) {
-                        const merged = mergeFunc(vs)
-                        chapterStrs.push(`${ch}:${merged.join(",")}`)
-                    }
-                })
-
-                if (chapterStrs.length === 0) {
-                    return cloned // no verses, perhaps error but return as is
-                }
-
-                const firstCh = sortedChs[0]
-                const lastCh = sortedChs[sortedChs.length - 1]
-                cloned.chapter = firstCh
-
-                const mergedFirst = mergeFunc(chapterVersesMap[firstCh] || new Set())
-                cloned.verses = mergedFirst
-
-                if (firstCh !== lastCh) {
-                    cloned.type = this.MULTI_CHAPTER_RANGE
-                    cloned.to = {
-                        book: cloned.book,
-                        chapter: lastCh,
-                        verses: mergeFunc(chapterVersesMap[lastCh] || new Set()),
-                    }
-                    cloned.original = `${cloned.book} ${chapterStrs.join("; ")}`
-                } else {
-                    const hasRangeOrMultiple =
-                        mergedFirst.length > 1 || (mergedFirst.length === 1 && mergedFirst[0].includes("-"))
-                    cloned.type = hasRangeOrMultiple ? this.CHAPTER_VERSE_RANGE : this.CHAPTER_VERSE
-                    if (cloned.to) delete cloned.to
-                    cloned.original = `${cloned.book} ${chapterStrs[0]}`
-                }
-
-                const chString = chapterStrs.join("; ")
-                cloned.scripture = {
-                    passage: `${cloned.book} ${chString}`,
-                    cv: chString,
-                    hash: `${cloned.book.toLowerCase()}_${chString
-                        .replace(/:/g, ".")
-                        .replace(/-/g, ".")
-                        .replace(/[,; ]/g, ".")}`,
-                }
-
-                // Set abbr
-                const sblEntry = Object.entries(self.sblAbbreviations).find(
-                    ([key]) => key.toLowerCase() === cloned.book.toLowerCase()
-                )
-                const suffix = versionObj.abbreviation === "eng" ? "" : ` ${versionObj.value}`
-                if (sblEntry) {
-                    const { value, abbr } = sblEntry[1]
-                    cloned.abbr = abbr
-                        ? `${value}. ${cloned.scripture.cv}${suffix}`
-                        : `${value} ${cloned.scripture.cv}${suffix}`
-                } else {
-                    cloned.abbr = `${cloned.book} ${cloned.scripture.cv}${suffix}`
-                }
-
-                return cloned
-            })
-
-            const newArray = [...converted]
-
-            newArray.first = function () {
-                return this.length > 0 ? this[0] : null
-            }
-
-            newArray.oldTestament = function () {
-                return this.filter((passage) => passage.testament === "old")
-            }
-
-            newArray.newTestament = function () {
-                return this.filter((passage) => passage.testament === "new")
-            }
-
-            newArray.combine = function (options = {}) {
-                const { book = true, chapter = true } = options
-
-                if (!book) {
-                    return [...this]
-                }
-
-                const groupedByBook = new Map()
-
-                this.forEach((passage) => {
-                    const bookKey = passage.book
-                    if (!groupedByBook.has(bookKey)) {
-                        groupedByBook.set(bookKey, [])
-                    }
-                    groupedByBook.get(bookKey).push(passage)
-                })
-
-                const combinedPassages = []
-
-                for (const [book, bookPassages] of groupedByBook) {
-                    if (chapter) {
-                        const groupedByChapter = new Map()
-                        bookPassages.forEach((passage) => {
-                            const chapterKey = `${passage.book}-${passage.chapter}`
-                            if (!groupedByChapter.has(chapterKey)) {
-                                groupedByChapter.set(chapterKey, [])
-                            }
-                            groupedByChapter.get(chapterKey).push(passage)
-                        })
-
-                        for (const passages of groupedByChapter.values()) {
-                            if (passages.length === 1) {
-                                combinedPassages.push({ ...passages[0] })
-                            } else {
-                                const combined = self.combine(passages)
-                                combinedPassages.push(combined)
-                            }
-                        }
-                    } else {
-                        const combined = self.combine(bookPassages)
-                        combinedPassages.push(combined)
-                    }
-                }
-
-                return combinedPassages
-            }
-
-            newArray.getVersion = passagesArray.getVersion
-
-            return newArray
-        }
-
-        return passagesArray
-    }
-
-    /**
-     * Returns the first parsed passage.
-     * @returns {Object|null} The first passage or null.
-     */
-    first() {
-        return this.passages.length > 0 ? this.passages[0] : null
-    }
-
-    /**
-     * Formats a passage into a human-readable reference.
-     * @param {Object} passage - The passage object.
-     * @returns {Object} Formatted passage data.
-     */
-    scripturize(passage) {
-        const formatChapterVerse = (chapter, verses) => {
-            if (!chapter || !verses || verses.length === 0) return ""
-            if (verses.length === 1) {
-                return `${chapter}:${verses[0]}`
-            }
-            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]}`
-            }
-            return `${chapter}:${verses.join(",")}`
-        }
-
-        let combined = `${passage.book}`
-        if (passage.type === "multi_chapter_verse_range" && passage.to) {
-            combined += ` ${formatChapterVerse(passage.chapter, passage.verses)}-${formatChapterVerse(
-                passage.to.chapter,
-                passage.to.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}`
-        } else {
-            combined += ` ${formatChapterVerse(passage.chapter, passage.verses)}`
-        }
-
-        const cv = passage.to
-            ? `${formatChapterVerse(passage.chapter, passage.verses)}-${formatChapterVerse(
-                  passage.to.chapter,
-                  passage.to.verses
-              )}`
-            : formatChapterVerse(passage.chapter, passage.verses)
-
-        const hash = `${passage.book.toLowerCase()}_${cv.replace(/:/g, ".").replace(/-/g, ".")}`
-
-        return {
-            passage: combined,
-            cv: cv,
-            hash: hash,
-        }
-    }
-
-    /**
-     * Combines multiple passages into a single reference.
-     * @param {Object[]} [passages=this.passages] - Array of passages to combine.
-     * @returns {Object} Combined passage object.
-     */
-    combine(passages = this.passages) {
-        if (!passages || passages.length === 0) {
-            throw new Error("No passages provided to join.")
-        }
-
-        const uniqueBooks = [...new Set(passages.map((p) => p.book))]
-        if (uniqueBooks.length > 1) {
-            throw new Error("Passages must be from the same book to join.")
-        }
-
-        const versions = new Set(passages.map((p) => p.version.abbreviation))
-        if (versions.size > 1) {
-            throw new Error("Cannot combine passages from different versions.")
-        }
-
-        const combined = {
-            ...passages[0],
-            verses: [],
-            passages: [],
-            to: null,
-            scripture: {},
-            type: null,
-            start: null,
-            end: null,
-        }
-
-        const chapterVerses = {}
-        let firstChapter = null
-        let lastChapter = null
-        let firstVerse = null
-        let lastVerse = null
-
-        passages.forEach((passage) => {
-            passage.passages.forEach((p) => {
-                const chapter = p.chapter
-                const verse = p.verse
-                if (!chapterVerses[chapter]) {
-                    chapterVerses[chapter] = new Set()
-                }
-                chapterVerses[chapter].add(verse)
-                combined.passages.push({
-                    book: p.book,
-                    chapter: p.chapter,
-                    verse: p.verse,
-                    versification: p.versification,
-                })
-
-                if (firstChapter === null || chapter < firstChapter) {
-                    firstChapter = chapter
-                    firstVerse = verse
-                } else if (chapter === firstChapter && (firstVerse === null || verse < firstVerse)) {
-                    firstVerse = verse
-                }
-                if (lastChapter === null || chapter > lastChapter) {
-                    lastChapter = chapter
-                    lastVerse = verse
-                } else if (chapter === lastChapter && (lastVerse === null || verse > lastVerse)) {
-                    lastVerse = verse
-                }
-            })
-        })
-
-        combined.passages = Array.from(new Set(combined.passages.map(JSON.stringify))).map(JSON.parse)
-
-        const chapterStrings = []
-        const sortedChapters = Object.keys(chapterVerses)
-            .map(Number)
-            .sort((a, b) => a - b)
-
-        sortedChapters.forEach((chapter) => {
-            const verses = Array.from(chapterVerses[chapter])
-                .map(Number)
-                .filter((verse) => verse > 0)
-                .sort((a, b) => a - b)
-            if (verses.length > 0) {
-                const mergedVerses = this.mergeRanges(verses)
-                chapterStrings.push(`${chapter}:${mergedVerses.join(",")}`)
-                if (chapter === firstChapter) {
-                    combined.verses = mergedVerses
-                }
-            }
-        })
-
-        if (chapterStrings.length === 0) {
-            throw new Error("No valid verses found in passages.")
-        }
-
-        combined.chapter = firstChapter
-
-        if (firstChapter !== lastChapter) {
-            combined.type = this.MULTI_CHAPTER_RANGE
-            combined.to = {
-                book: combined.book,
-                chapter: lastChapter,
-                verses: this.mergeRanges(
-                    Array.from(chapterVerses[lastChapter])
-                        .filter((verse) => verse > 0)
-                        .sort((a, b) => a - b)
-                ),
-            }
-            combined.original = `${combined.book} ${chapterStrings.join("; ")}`
-        } else {
-            combined.type = combined.verses.length > 1 ? this.CHAPTER_VERSE_RANGE : this.CHAPTER_VERSE
-            combined.original = `${combined.book} ${chapterStrings[0]}`
-        }
-
-        const chapterString = chapterStrings.join(";")
-        combined.scripture = {
-            passage: `${combined.book} ${chapterString}`,
-            cv: chapterString,
-            hash: `${combined.book.toLowerCase()}_${chapterString
-                .replace(/:/g, ".")
-                .replace(/-/g, ".")
-                .replace(/[,;]/g, ".")}`,
-        }
-
-        combined.start = {
-            book: combined.book,
-            chapter: firstChapter,
-            verse:
-                firstVerse > 0
-                    ? firstVerse
-                    : Math.min(...Array.from(chapterVerses[firstChapter]).filter((verse) => verse > 0)),
-        }
-        combined.end = {
-            book: combined.book,
-            chapter: lastChapter,
-            verse:
-                lastVerse > 0
-                    ? lastVerse
-                    : Math.max(...Array.from(chapterVerses[lastChapter]).filter((verse) => verse > 0)),
-        }
-
-        combined.reference = function () {
-            return this.scripture.passage
-        }
-
-        if (combined.to === null) {
-            delete combined.to
-        }
-
-        // Respect the common version
-        combined.version = passages[0].version
-
-        // Set abbr with version suffix if not ENG
-        const sblEntry = Object.entries(this.sblAbbreviations).find(
-            ([key]) => key.toLowerCase() === combined.book.toLowerCase()
-        )
-        const suffix = combined.version.abbreviation === "eng" ? "" : ` ${combined.version.value}`
-        if (sblEntry) {
-            const { value, abbr } = sblEntry[1]
-            combined.abbr = abbr
-                ? `${value}. ${combined.scripture.cv}${suffix}`
-                : `${value} ${combined.scripture.cv}${suffix}`
-        } else {
-            combined.abbr = `${combined.book} ${combined.scripture.cv}${suffix}`
-        }
-
-        const self = this
-        combined.getVersion = function (targetVersion) {
-            const cloned = JSON.parse(JSON.stringify(this))
-            const targetAbbr = targetVersion.toLowerCase() === "bhs" ? "mt" : targetVersion.toLowerCase()
-            let versionObj
-            if (targetAbbr === "eng") {
-                versionObj = { name: "English", value: "ENG", abbreviation: "eng" }
-            } else if (targetAbbr === "mt") {
-                versionObj = { name: "Masoretic Text", value: "MT", abbreviation: "mt" }
-            } else if (targetAbbr === "lxx") {
-                versionObj = { name: "Septuagint", value: "LXX", abbreviation: "lxx" }
-            } else {
-                throw new Error("Invalid version: must be one of 'eng', 'mt', 'bhs', 'lxx'")
-            }
-
-            cloned.version = versionObj
-
-            cloned.passages.forEach((sub) => {
-                if (sub.versification && sub.versification[targetAbbr]) {
-                    const [ch, v] = sub.versification[targetAbbr].split(":").map(Number)
-                    sub.chapter = ch
-                    sub.verse = v
-                }
-                // else remain unchanged
-            })
-
-            // Recompute summary fields
-            cloned.passages.sort((a, b) => a.chapter - b.chapter || a.verse - b.verse)
-
-            if (cloned.passages.length > 0) {
-                cloned.start = {
-                    book: cloned.book,
-                    chapter: cloned.passages[0].chapter,
-                    verse: cloned.passages[0].verse,
-                }
-                cloned.end = {
-                    book: cloned.book,
-                    chapter: cloned.passages[cloned.passages.length - 1].chapter,
-                    verse: cloned.passages[cloned.passages.length - 1].verse,
-                }
-            }
-
-            const chapterVersesMap = {}
-            cloned.passages.forEach((p) => {
-                if (!chapterVersesMap[p.chapter]) chapterVersesMap[p.chapter] = new Set()
-                chapterVersesMap[p.chapter].add(p.verse)
-            })
-
-            const sortedChs = Object.keys(chapterVersesMap)
-                .map(Number)
-                .sort((a, b) => a - b)
-            const chapterStrs = []
-
-            const mergeFunc = (verses) => {
-                const sorted = [...verses].sort((a, b) => a - b)
-                const merged = []
-                if (sorted.length === 0) return merged
-                let start = sorted[0]
-                let end = sorted[0]
-                for (let i = 1; i < sorted.length; i++) {
-                    if (sorted[i] === end + 1) {
-                        end = sorted[i]
-                    } else {
-                        merged.push(start === end ? `${start}` : `${start}-${end}`)
-                        start = end = sorted[i]
-                    }
-                }
-                merged.push(start === end ? `${start}` : `${start}-${end}`)
-                return merged
-            }
-
-            sortedChs.forEach((ch) => {
-                const vs = Array.from(chapterVersesMap[ch])
-                    .filter((v) => v > 0)
-                    .sort((a, b) => a - b)
-                if (vs.length > 0) {
-                    const merged = mergeFunc(vs)
-                    chapterStrs.push(`${ch}:${merged.join(",")}`)
-                }
-            })
-
-            if (chapterStrs.length === 0) {
-                return cloned // no verses, perhaps error but return as is
-            }
-
-            const firstCh = sortedChs[0]
-            const lastCh = sortedChs[sortedChs.length - 1]
-            cloned.chapter = firstCh
-
-            const mergedFirst = mergeFunc(chapterVersesMap[firstCh] || new Set())
-            cloned.verses = mergedFirst
-
-            if (firstCh !== lastCh) {
-                cloned.type = "multi_chapter_verse_range"
-                cloned.to = {
-                    book: cloned.book,
-                    chapter: lastCh,
-                    verses: mergeFunc(chapterVersesMap[lastCh] || new Set()),
-                }
-                cloned.original = `${cloned.book} ${chapterStrs.join("; ")}`
-            } else {
-                const hasRangeOrMultiple =
-                    mergedFirst.length > 1 || (mergedFirst.length === 1 && mergedFirst[0].includes("-"))
-                cloned.type = hasRangeOrMultiple ? "chapter_verse_range" : "chapter_verse"
-                if (cloned.to) delete cloned.to
-                cloned.original = `${cloned.book} ${chapterStrs[0]}`
-            }
-
-            const chString = chapterStrs.join("; ")
-            cloned.scripture = {
-                passage: `${cloned.book} ${chString}`,
-                cv: chString,
-                hash: `${cloned.book.toLowerCase()}_${chString
-                    .replace(/:/g, ".")
-                    .replace(/-/g, ".")
-                    .replace(/[,; ]/g, ".")}`,
-            }
-
-            // Set abbr
-            const sblEntry = Object.entries(self.sblAbbreviations).find(
-                ([key]) => key.toLowerCase() === cloned.book.toLowerCase()
-            )
-            const suffix = versionObj.abbreviation === "eng" ? "" : ` ${versionObj.value}`
-            if (sblEntry) {
-                const { value, abbr } = sblEntry[1]
-                cloned.abbr = abbr
-                    ? `${value}. ${cloned.scripture.cv}${suffix}`
-                    : `${value} ${cloned.scripture.cv}${suffix}`
-            } else {
-                cloned.abbr = `${cloned.book} ${cloned.scripture.cv}${suffix}`
-            }
-
-            cloned.getVersion = this.getVersion
-
-            return cloned
-        }
-
-        return combined
-    }
-
-    /**
-     * Merges verses into ranges or comma-separated lists.
-     * @param {number[]} verses - Array of verse numbers.
-     * @returns {string[]} Array of verse strings.
-     */
-    mergeRanges(verses) {
-        const sortedVerses = [...new Set(verses)].sort((a, b) => a - b)
-        const merged = []
-        let start = sortedVerses[0]
-        let end = sortedVerses[0]
-
-        for (let i = 1; i < sortedVerses.length; i++) {
-            if (sortedVerses[i] === end + 1) {
-                end = sortedVerses[i]
-            } else {
-                if (start === end) {
-                    merged.push(`${start}`)
-                } else {
-                    merged.push(`${start}-${end}`)
-                }
-                start = sortedVerses[i]
-                end = sortedVerses[i]
-            }
-        }
-
-        if (start === end) {
-            merged.push(`${start}`)
-        } else {
-            merged.push(`${start}-${end}`)
-        }
-
-        return merged
-    }
-
-    /**
-     * Generates a table of contents for the Bible.
-     * @param {string} [version="ESV"] - The Bible version.
-     * @returns {Object} TOC with book-chapter-verse mappings.
-     */
-    getToc(version = "ESV") {
-        const toc = {}
-        this.bible.old.forEach((book) => {
-            if (this.chapterVerses[book]) {
-                toc[book] = this.chapterVerses[book]
-            }
-        })
-        this.bible.new.forEach((book) => {
-            if (this.chapterVerses[book]) {
-                toc[book] = this.chapterVerses[book]
-            }
-        })
-        this.singleChapterBook.forEach((item) => {
-            Object.keys(item).forEach((book) => {
-                if (!toc[book]) {
-                    toc[book] = item[book]
-                }
-            })
-        })
-        const orderedToc = {}
-        const canonicalOrder = [...this.bible.old, ...this.bible.new]
-        canonicalOrder.forEach((book) => {
-            if (toc[book]) {
-                orderedToc[book] = toc[book]
-            }
-        })
-        return orderedToc
-    }
-
-    /**
-     * Validates a passage for correctness.
-     * @param {Object} passage - The passage object.
-     * @param {string} reference - The original reference.
-     * @returns {boolean|Object} True if valid, error object if invalid.
-     * @private
-     */
-    _isValid(passage, reference) {
-        const { book, chapter, verses, type } = passage
-
-        if (!verses.length && type !== this.SINGLE_CHAPTER) {
-            return this.validationError(101, `Possible invalid chapter: ${reference}`)
-        }
-
-        const chapterVerses = this.getChapterVerses(book, chapter)
-        if (!chapterVerses.length) {
-            return this.validationError(102, `Chapter ${chapter} does not exist in ${book}`)
-        }
-
-        if (type === this.SINGLE_CHAPTER) {
-            const [range] = verses
-            if (range) {
-                const [start, end] = range.split("-").map(Number)
-                if (start < 1 || end > chapterVerses[chapterVerses.length - 1]) {
-                    return this.validationError(
-                        104,
-                        `Verse range ${start}-${end} exceeds available verses (1-${
-                            chapterVerses[chapterVerses.length - 1]
-                        }) in ${book} ${chapter}`
-                    )
-                }
-            }
-            return true
-        }
-
-        return this.validateVerses(book, chapter, verses, reference)
-    }
-
-    /**
-     * Validates verse numbers for a chapter.
-     * @param {string} book - The book name.
-     * @param {number} chapter - The chapter number.
-     * @param {Array<string|number>} verses - Array of verses or ranges.
-     * @param {string} reference - The original reference.
-     * @returns {boolean|Object} True if valid, error object if invalid.
-     * @private
-     */
-    validateVerses(book, chapter, verses, reference) {
-        const chapterVerses = this.getChapterVerses(book, chapter)
-        for (const verse of verses) {
-            const verseRange = String(verse)
-            const verseNumbers = verseRange.includes("-")
-                ? Array.from(
-                      { length: Number(verseRange.split("-")[1]) - Number(verseRange.split("-")[0]) + 1 },
-                      (_, i) => Number(verseRange.split("-")[0]) + i
-                  )
-                : [Number(verseRange)]
-
-            for (const v of verseNumbers) {
-                if (isNaN(v) || v <= 0 || !chapterVerses.includes(v)) {
-                    return this.validationError(104, `Verse number ${v} does not exist in ${book} ${chapter}`)
-                }
-            }
-        }
-        return true
-    }
-
-    /**
-     * Creates an error object for validation failures.
-     * @param {number} code - Error code.
-     * @param {string} message - Error message.
-     * @returns {Object} Error object.
-     * @private
-     */
-    validationError(code, message) {
-        return {
-            error: true,
-            code,
-            message: { verse_exists: code === 104, chapter_exists: code !== 104, content: message },
-        }
-    }
-
-    /**
-     * Determines the Bible version for a passage.
-     * @param {string} version - The version (e.g., "lxx").
-     * @param {string} testament - The testament ("old" or "new").
-     * @returns {Object} Version object.
-     * @private
-     */
-    _handleVersion(version, testament) {
-        const effectiveVersion = this.version || version || "eng"
-        const lowerVersion = effectiveVersion.toLowerCase()
-
-        if (lowerVersion === "lxx" && testament === "old") {
-            return { name: "Septuagint", value: "LXX", abbreviation: "lxx" }
-        }
-        if (lowerVersion === "mt" && testament === "old") {
-            return { name: "Masoretic Text", value: "MT", abbreviation: "mt" }
-        }
-        return { name: "English", value: "ENG", abbreviation: "eng" }
-    }
-
-    /**
-     * Replaces scripture references in text with formatted references.
-     * @param {string} text - The original text.
-     * @param {boolean} useAbbreviations - Whether to use abbreviated book names.
-     * @returns {string} Text with replaced references.
-     */
-    replace(text, useAbbreviations = true) {
-        if (!this.passages.length) {
-            return text
-        }
-
-        let result = text
-        for (let i = this.passages.length - 1; i >= 0; i--) {
-            const passage = this.passages[i]
-            const { originalText, abbr, original } = passage
-            const newReference = useAbbreviations ? abbr : original
-
-            const regex = new RegExp(`${originalText.replace(/([.*+?^${}()|[\]\\])/g, "\\$1")}`, "g")
-
-            const matches = [...result.matchAll(regex)]
-            if (matches.length > 0) {
-                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] || ""
-                    const hasOpeningParen = match[2] === "("
-                    const hasClosingParen = match[3] === ")"
-                    const trailingSpace = match[4] || " "
-                    const replacement =
-                        hasOpeningParen && hasClosingParen
-                            ? `${leadingSpace}(${newReference})${trailingSpace}`
-                            : `${leadingSpace}${newReference}${trailingSpace}`
-                    result = result.slice(0, startIndex) + replacement + result.slice(endIndex)
-                }
-            }
-        }
-
-        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.
-     */
-    same() {
-        if (this.passages.length <= 1) {
-            return true
-        }
-
-        const firstBook = this.passages[0].book.toLowerCase()
-        return this.passages.every((passage) => passage.book.toLowerCase() === firstBook)
-    }
-}
-
-module.exports = CodexParser