Hebrew Holy Tanakh

https://github.com/wjbaker2025/hebrew-holy-tanakh
Admin
A digitized, parseable version of the Hebrew Bible with morphological parsing, gematria analysis...
Tokens:10,647
Snippets:47
Trust Score:6
License:MIT
Update:8 months ago
Show doc for...
Tokens:
Raw
### Hebrew Letter Alphabet Map Definition and Access (JavaScript)

Source: https://context7.com/wjbaker2025/hebrew-holy-tanakh/llms.txt

Provides a comprehensive map of Hebrew letters, including their names, Greek equivalents, phonetic values, theurgy symbols, physics associations, and pneumatic meanings. Includes an example of accessing letter properties.

```javascript
const alphabetMap = {
  "א": {
    name: "aleph",
    greek: "alpha",
    phonetic: "Al",
    theurgy: "אֵל",
    physics: "Angular Acceleration / Fine-Structure",
    pneumatic: "The Impulse of Will",
    value: 1
  },
  "ב": {
    name: "bet",
    greek: "beta",
    phonetic: "Be",
    theurgy: "בֶּ",
    physics: "Relativistic Velocity Ratio (v/c) / Phase Constant",
    pneumatic: "The Fluidity of State",
    value: 2
  },
  "ג": {
    name: "gimel",
    greek: "gamma",
    phonetic: "Ga",
    theurgy: "גַּ",
    physics: "Lorentz Factor / Adiabatic Index",
    pneumatic: "The Energy of Transmutation",
    value: 3
  },
  "ל": {
    name: "lamed",
    greek: "lambda",
    phonetic: "Lam",
    theurgy: "לָם",
    physics: "Wavelength / Cosmological Constant",
    pneumatic: "The Frequency of Instruction",
    value: 30
  },
  "ר": {
    name: "resh",
    greek: "rho",
    phonetic: "Re",
    theurgy: "רֵ",
    physics: "Density / Resistivity",
    pneumatic: "The Concentration of Essence",
    value: 200
  }
};

// Access letter properties
const aleph = alphabetMap["א"];
console.log(`${aleph.name}: physics=${aleph.physics}, pneumatic=${aleph.pneumatic}`);
// aleph: physics=Angular Acceleration / Fine-Structure, pneumatic=The Impulse of Will
```

--------------------------------

### Genesis Order Cipher Definition and Calculation (JavaScript)

Source: https://context7.com/wjbaker2025/hebrew-holy-tanakh/llms.txt

Defines the Genesis Order Cipher, a numerical sequence based on letter order in Genesis 1-2. It includes code to calculate the sum of this sequence and an example of its application to a Hebrew word.

```javascript
const genesisOrderCipher = {
  "ב": 1,   "א": 2,   "ג": 3,   "ש": 3,   "ד": 4,   "ת": 4,
  "ה": 5,   "ו": 6,   "ז": 7,   "ח": 8,   "ט": 9,   "י": 10,
  "כ": 11,  "ל": 12,  "מ": 13,  "נ": 14,  "ס": 15,  "ע": 16,
  "פ": 17,  "צ": 18,  "ק": 19,  "ר": 20
};

// Verify sum equals 217 (31 × 7, where 31 = אל in Biblical cipher)
const sequence = [1,2,3,3,4,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20];
const genesisSum = sequence.reduce((a, b) => a + b, 0);
console.log(`Genesis Order Sum: ${genesisSum}`); // 217

// Example: Calculate "בראשית" in Genesis Order
// ב=1, ר=20, א=2, ש=3, י=10, ת=4
// Result: 1 + 20 + 2 + 3 + 10 + 4 = 40
```

--------------------------------

### Analyze Verses and Words with Strong's Concordance in JavaScript

Source: https://context7.com/wjbaker2025/hebrew-holy-tanakh/llms.txt

Provides functions to load biblical texts, iterate through verses, and analyze individual words with their Strong's concordance references. It also includes a function to find all occurrences of a specific Strong's number within a book.

```javascript
// Load a book and iterate through verses
const genesis = require('./Tanakh/1. Torah - Instructions/01_genesis.json');

function analyzeVerse(book, chapter, verse) {
  const words = book.Genesis.chapters[chapter][verse];
  const analysis = [];

  for (const word of words) {
    analysis.push({
      hebrew: word.hebrew,
      english: word.english,
      strongs: word.strongs,
      morphology: word.morphology,
      strongsUrl: `https://www.blueletterbible.org/lexicon/h${word.strongs}/wlc/wlc/0-1/`
    });
  }
  return analysis;
}

// Analyze Genesis 1:1
const gen1_1 = analyzeVerse(genesis, "1", "1");
console.log(gen1_1);
// [
//   { hebrew: "בְּרֵאשִׁ֖ית", english: "In the beginning", strongs: "7225", ... },
//   { hebrew: "בָּרָ֣א", english: "created", strongs: "1254", ... },
//   { hebrew: "אֱלֹהִ֑ים", english: "God", strongs: "430", ... },
//   ...
// ]

// Find all verses containing a specific Strong's number
function findByStrongs(book, targetStrongs) {
  const results = [];
  for (const [chapterNum, chapter] of Object.entries(book.Genesis.chapters)) {
    for (const [verseNum, words] of Object.entries(chapter)) {
      for (const word of words) {
        if (word.strongs === targetStrongs) {
          results.push({ chapter: chapterNum, verse: verseNum, word: word });
        }
      }
    }
  }
  return results;
}

// Find all occurrences of "אלהים" (Elohim, Strong's 430)
const elohimOccurrences = findByStrongs(genesis, "430");
```

--------------------------------

### JavaScript App Logic for Bible Display and Data Fetching

Source: https://github.com/wjbaker2025/hebrew-holy-tanakh/blob/main/bible_app.html

Handles the application's core logic, including initializing the document, fetching biblical data (either from a local server or using demo data), rendering the page with verses and words, and implementing search/highlighting functionality.

```javascript
// --- 3. APP LOGIC ---
// Initialize
document.addEventListener('DOMContentLoaded', () => {
  // Check if we can fetch real files (Local Server Mode)
  // If not, use embedded demo data
  fetchData();
});

async function fetchData() {
  try {
    // Attempt to fetch the user's actual file structure
    const response = await fetch('Tanakh/1. Torah - Instructions/01_genesis.json');
    if (response.ok) {
      const data = await response.json();
      bibleData["Genesis"] = data["Genesis"]; // Overlay real data
    }
  } catch (e) {
    console.log("Using demo data (Use the PowerShell script to load local files)");
  }
  renderPage();
}

function renderPage() {
  const container = document.getElementById('bible-text');
  const chapters = bibleData[currentBook]?.chapters;
  if (!chapters || !chapters[currentChapter]) {
    container.innerHTML = `<div style="padding:20px;">End of available text or Chapter ${currentChapter} not found.</div>`;
    return;
  }
  const versesObj = chapters[currentChapter];
  let html = `<div class="chapter-title">${currentBook} Chapter ${currentChapter}</div>`;
  // Sort verses just in case keys are unordered
  const verseKeys = Object.keys(versesObj).sort((a,b) => parseInt(a) - parseInt(b));
  verseKeys.forEach(vNum => {
    const words = versesObj[vNum];
    html += `<div class="verse-container"><span class="verse-number">${vNum}</span>`;
    words.forEach(word => {
      const isMatch = checkMatch(word);
      const highlightClass = isMatch ? 'imprinted' : '';
      html += ` <div class="word-card ${highlightClass}"> <div class="word-hebrew">${word.hebrew || ""}</div> <div class="word-english">${word.english || "-"}</div> </div> `;
    });
    html += `</div>`;
  });
  container.innerHTML = html;
  document.getElementById('current-location').innerText = `${currentBook} ${currentChapter}`;
}

function checkMatch(wordObj) {
  if (!activeSearchTerm) return false;
  const term = activeSearchTerm.trim().toLowerCase();
  const eng = (wordObj.english || "").toLowerCase();
  const heb = (wordObj.hebrew || "");
  // Simple string matching
  // Remove cantillation marks from hebrew for better matching if needed
  // For now, strict match
  return eng.includes(term) || heb.includes(term);
}

function imprintGematria() {
  const input = document.getElementById('gematria-search');
  activeSearchTerm = input.value;
  // Calculate Value (If hebrew is entered)
  const val = calculateGematria(activeSearchTerm);
  document.getElementById('gematria-result').innerHTML = `Value: <span class="gematria-value">${val > 0 ? val : 'N/A'}</span> (Biblical)`;
  // Re-render to apply highlights
  renderPage();
}

function handleEnter(e) {
  if (e.key === 'Enter') imprintGematria();
}

// Navigation
function nextChapter() {
  currentChapter++;
  renderPage();
  document.getElementById('reader-container').scrollTop = 0;
}

function prevChapter() {
  if (currentChapter > 1) {
    currentChapter--;
    renderPage();
    document.getElementById('reader-container').scrollTop = 0;
  }
}

function loadBook(bookName) {
  currentBook = bookName;
  currentChapter = 1;
  // Update active sidebar tab
  document.querySelectorAll('.book-item').forEach(el => el.classList.remove('active'));
  event.target.classList.add('active');
  renderPage();
}

```

--------------------------------

### JavaScript Configuration and Embedded Data

Source: https://github.com/wjbaker2025/hebrew-holy-tanakh/blob/main/bible_app.html

Initializes application state variables like current book, chapter, and search term. Includes embedded demo data for Genesis Chapter 1 as a fallback, simulating fetched JSON data.

```javascript
// --- 1. CONFIGURATION & DATA ---
let currentBook = "Genesis";
let currentChapter = 1;
let activeSearchTerm = "";

// Embedded DEMO Data (Genesis Ch 1 truncated for brevity, acts as fallback)
// In a real scenario, this fetches from your JSON files.
const bibleData = {
  "Genesis": {
    "chapters": {
      "1": {
        "1": [
          {"hebrew": "בְּרֵאשִׁ֖ית", "english": "In the beginning"},
          {"hebrew": "בָּרָ֣א", "english": "created"},
          {"hebrew": "אֱלֹהִ֑ים", "english": "God"},
          {"hebrew": "אֵ֥ת", "english": "-"},
          {"hebrew": "הַשָּׁמַ֖יִם", "english": "the heavens"},
          {"hebrew": "וְאֵ֥ת", "english": "and"},
          {"hebrew": "הָאָֽרֶץ׃", "english": "the earth"}
        ],
        "2": [
          {"hebrew": "וְהָאָ֗רֶץ", "english": "And the earth"},
          {"hebrew": "הָיְתָ֥ה", "english": "was"},
          {"hebrew": "תֹ֙הוּ֙", "english": "formless"},
          {"hebrew": "וָבֹ֔הוּ", "english": "and void"},
          {"hebrew": "וְחֹ֖שֶׁךְ", "english": "and darkness"},
          {"hebrew": "עַל־", "english": "over"},
          {"hebrew": "פְּנֵ֣י", "english": "the face"},
          {"hebrew": "תְה֑וֹם", "english": "of the deep"}
        ]
      },
      "2": {
        "1": [
          {"hebrew": "וַיְכֻלּ֛וּ", "english": "Thus were finished"},
          {"hebrew": "הַשָּׁמַ֥יִם", "english": "the heavens"},
          {"hebrew": "וְהָאָ֖רֶץ", "english": "and the earth"}
        ]
      }
    }
  }
};

```

--------------------------------

### Define Shematria Rules and Seven Palaces Topology in JavaScript

Source: https://context7.com/wjbaker2025/hebrew-holy-tanakh/llms.txt

Defines advanced shematria calculation rules based on the Seven Palaces system, including node positions, mathematical operators, and set values for specific words. This JSON structure is used to configure gematria calculations.

```javascript
const shematriaRules = {
  seven_palaces_topology: {
    nodes: {
      center_core: { letter: "ר", value: 200, location: "CPU_CORE", pos: [0, 0, 0] },
      top_gate: { letter: "ב", value: 2, location: "INPUT_GATE", pos: [0, 10, 0] },
      right_gate: { letter: "א", value: 1, location: "RIGHT_TERMINAL", pos: [10, 0, 0] },
      left_gate: { letter: "א", value: 1, location: "LEFT_TERMINAL", pos: [-10, 0, 0] },
      bottom_gate: { letter: "ה", value: 5, location: "GROUND", pos: [0, -10, 0] },
      inner_right_spoke: { letter: "ד", value: 4, location: "INNER_GATE_R", pos: [5, -5, 0] },
      inner_left_spoke: { letter: "ד", value: 4, location: "INNER_GATE_L", pos: [-5, -5, 0] }
    },
    operators: {
      multipliers: { "ברוך": 2 },        // "blessed" = multiply by 2
      divisors: { "ארור": 2, "בין": 2 }, // "cursed", "between" = divide by 2
      modifiers: { "מעל": "ADD", "מתחת": "SUB", "את": "MARKER" }
    },
    // Set values for specific words (override calculated gematria)
    set_values: {
      "בית": 2, "רוח": 2, "באפיו": 2, "רקיע": 3, "יבשה": 3,
      "דלתות": 4, "תדשא": 4, "הכוכבים": 5, "יד": 20, "נחש": 50,
      "עיניים": 70, "עין": 70, "פה": 80, "כנפות": 90, "אשה": 111
    },
    // Middot (measures) used in calculations
    middot: ["יום", "לילה", "שנה", "שבוע", "חודש", "מועד", "עת", "שם", "דבר", "אמר"]
  }
};

// Apply shematria operator
function applyOperator(value, operatorWord, operators) {
  if (operators.multipliers[operatorWord]) {
    return value * operators.multipliers[operatorWord];
  }
  if (operators.divisors[operatorWord]) {
    return value / operators.divisors[operatorWord];
  }
  return value;
}
```

--------------------------------

### JSON Structure for Biblical Books

Source: https://github.com/wjbaker2025/hebrew-holy-tanakh/blob/main/README.md

Demonstrates the hierarchical JSON structure for storing biblical books, chapters, verses, and individual words. Each word object contains its Strong's number, Hebrew text, English translation, and morphological parsing tags.

```json
{
  "Genesis": {
    "chapters": {
      "1": {
        "1": [
          {
            "strongs": "7225",
            "hebrew": "בְּרֵאשִׁ֖ית",
            "english": "In the beginning",
            "morphology": "Preposition-b :: Noun - feminine singular"
          }
        ]
      }
    }
  }
}
```

--------------------------------

### JavaScript Cipher Configuration

Source: https://github.com/wjbaker2025/hebrew-holy-tanakh/blob/main/README.md

Provides a JavaScript configuration file for defining and implementing various gematria cipher systems. This file likely contains the logic or settings required to apply different ciphers to the textual data.

```javascript
// Example placeholder for ciphers_2026-01-13_12-36-32.js
// This file would contain JavaScript code for cipher implementations or configurations.
```

--------------------------------

### Multiscript Gematria Mappings (JSON)

Source: https://context7.com/wjbaker2025/hebrew-holy-tanakh/llms.txt

Defines cross-language gematria mappings for Hebrew, Greek, and Arabic alphabets. This JSON data can be used to calculate equivalent numerical values for characters across different scripts, facilitating comparative textual analysis.

```javascript
const multiscriptMap = {
  hebrew: {
    "א": 1, "ב": 2, "ג": 3, "ד": 4, "ה": 5, "ו": 6, "ז": 7, "ח": 8,
    "ט": 9, "י": 10, "כ": 20, "ל": 30, "מ": 40, "נ": 50, "ס": 60,
    "ע": 70, "פ": 80, "צ": 90, "ק": 100, "ר": 200, "ש": 300, "ת": 400
  },
  greek: {
    "Α": 1, "Β": 2, "Γ": 3, "Δ": 4, "Ε": 5, "Ζ": 7, "Η": 8, "Θ": 9,
    "Ι": 10, "Κ": 20, "Λ": 30, "Μ": 40, "Ν": 50, "Ξ": 60, "Ο": 70,
    "Π": 80, "Ρ": 100, "Σ": 200, "Τ": 300, "Υ": 400, "Φ": 500,
    "Χ": 600, "Ψ": 700, "Ω": 800
  },
  arabic: {
    "ا": 1, "ب": 2, "ج": 3, "د": 4, "ه": 5, "و": 6, "ز": 7, "ح": 8,
    "ط": 9, "ي": 10, "ك": 20, "ل": 30, "م": 40, "ن": 50, "س": 60,
    "ع": 70, "ف": 80, "ص": 90, "ق": 100, "ر": 200, "ش": 300, "ت": 400
  }
};

// Calculate equivalent values across scripts
function calculateMultiscript(text, language) {
  const charMap = multiscriptMap[language];
  return [...text].reduce((sum, char) => sum + (charMap[char] || 0), 0);
}

// Hebrew: שלום = 300+30+6+40 = 376 (using standard values)
// Greek: ΣΛΩΜ would be 200+30+800+40 = 1070 (using Greek isopsephy)

```

--------------------------------

### Hebrew Morphological Parsing Legend (JSON)

Source: https://context7.com/wjbaker2025/hebrew-holy-tanakh/llms.txt

Provides a comprehensive legend for interpreting morphological parsing tags used in Tanakh word data. It details verb stems, aspects, grammatical features, conjunctions, prepositions, articles, and direct object markers.

```javascript
const parsingTagLegend = {
  tags: {
    "Conj": {
      full_name: "Conjunction",
      types: { "w": { strong: "9999", transliteration: "waw", translation: ["and", "furthermore", "but..."] }}
    },
    "Prep": {
      full_name: "Preposition",
      types: {
        "b": { strong: "9996", transliteration: "b^e", translation: "in" },
        "k": { strong: "9995", transliteration: "k^e", translation: "according to" },
        "l": { strong: "9997", transliteration: "l^e", translation: "with regard to" },
        "m": { strong: "4480", transliteration: "min", translation: "from" }
      }
    },
    "V": {
      full_name: "Verb",
      stems: ["Hiphil", "Hophal", "Piel", "Pual", "Hithpael", "Qal", "Nifal", "Qalpass"],
      aspects: {
        main: {
          "Perf": "Perfect",
          "Imperf": "Imperfect",
          "ConjPerf": "Conjunctive Perfect",
          "ConjImperf": "Conjunctive Imperfect",
          "ConsecImperf": "Consecutive Imperfect"
        }
      },
      person: { "1": "1st Person", "2": "2nd Person", "3": "3rd Person" },
      gender: { "m": "masculine", "f": "feminine", "c": "common" },
      number: { "s": "singular", "p": "plural" }
    },
    "Art": { full_name: "Definite Article", type: { strong: "9998", transliteration: "hä", translation: "the" }},
    "DirObjM": { full_name: "Direct Object Marker", type: { strong: "853", transliteration: "eth" }}
  }
};

// Parse morphology string: "Verb - Qal - Perfect - third person masculine singular"
function parseMorphology(morphString) {
  const parts = morphString.split(" - ");
  return {
    pos: parts[0],           // "Verb"
    stem: parts[1],          // "Qal"
    aspect: parts[2],        // "Perfect"
    details: parts[3]        // "third person masculine singular"
  };
}

// Example from Genesis 1:1 word "בָּרָ֣א" (created)
const word = { morphology: "Verb - Qal - Perfect - third person masculine singular" };
const parsed = parseMorphology(word.morphology);
// { pos: "Verb", stem: "Qal", aspect: "Perfect", details: "third person masculine singular" }

```

--------------------------------

### Reversal Cipher Definition and Pairs (JavaScript)

Source: https://context7.com/wjbaker2025/hebrew-holy-tanakh/llms.txt

Implements the Reversal Cipher, assigning numerical values in reverse order for complementary meanings. It includes the cipher definition and a structure for reversal pairs.

```javascript
const reversalCipher = {
  "ת": 80,  "ש": 90,  "ר": 2,   "ק": 1,   "צ": 3,   "פ": 4,
  "ע": 5,   "ס": 6,   "נ": 7,   "מ": 8,   "ל": 9,   "כ": 10,
  "י": 20,  "ט": 30,  "ח": 40,  "ז": 50,  "ו": 60,  "ה": 70,
  "ד": 80,  "ג": 90,  "ב": 200, "א": 100
};

// Reversal pairs (each letter pairs with its mirror)
const reversalPairs = {
  "א": "ק",  // Aleph (1) ↔ Qoph (100)
  "ב": "ר",  // Beth (2) ↔ Resh (200)
  "ג": "צ",  // Gimel (3) ↔ Tsade (90)
  "ד": "ף",  // Daleth (4) ↔ Final Peh (80)
  "ה": "ע",  // Heh (5) ↔ Ayin (70)
  "ו": "ס",  // Waw (6) ↔ Samekh (60)
  "ז": "ן",  // Zayin (7) ↔ Final Nun (50)
};

// Example: Find complementary word values
const word1 = "אב"; // Father: Biblical = 3, Reversal = 300
const word2 = "קר"; // Cold: Biblical = 300, Reversal = 3
```

--------------------------------

### Standard Gematria Calculation (JavaScript)

Source: https://context7.com/wjbaker2025/hebrew-holy-tanakh/llms.txt

Implements the Standard Hebrew gematria system (Mispar Hechrechi), where Shin (ש) is 300 and Tav (ת) is 400. This JavaScript code calculates the numerical value of a Hebrew word, handling final letter forms.

```javascript
const standardCipher = {
  "א": 1,   "ב": 2,   "ג": 3,   "ד": 4,   "ה": 5,   "ו": 6,
  "ז": 7,   "ח": 8,   "ט": 9,   "י": 10,  "כ": 20,  "ל": 30,
  "מ": 40,  "נ": 50,  "ס": 60,  "ע": 70,  "פ": 80,  "צ": 90,
  "ק": 100, "ר": 200, "ש": 300, "ת": 400
};

// Example: Calculate standard gematria of "אלהים" (God/Elohim)
// א=1, ל=30, ה=5, י=10, ם=40 (final mem uses mem value)
// Result: 1 + 30 + 5 + 10 + 40 = 86
const elohim = "אלהים";
let total = 0;
for (const char of elohim) {
  // Handle final forms by mapping to base letter value
  const baseChar = char === 'ם' ? 'מ' : char;
  if (standardCipher[baseChar]) {
    total += standardCipher[baseChar];
  }
}
console.log(`${elohim} = ${total}`); // אלהים = 86
```

--------------------------------

### Biblical Gematria Calculation (JavaScript)

Source: https://context7.com/wjbaker2025/hebrew-holy-tanakh/llms.txt

Implements the Biblical gematria cipher, a variation where Shin (ש) is 3 and Tav (ת) is 4. This JavaScript function calculates the numerical value of a Hebrew word using a provided cipher object.

```javascript
const biblicalCipher = {
  "א": 1,   "ב": 2,   "ג": 3,   "ש": 3,   "ד": 4,   "ת": 4,
  "ה": 5,   "ו": 6,   "ז": 7,   "ח": 8,   "ט": 9,   "י": 10,
  "כ": 20,  "ל": 30,  "מ": 40,  "נ": 50,  "ס": 60,  "ע": 70,
  "פ": 80,  "צ": 90,  "ק": 100, "ר": 200
};

// Calculate gematria for a Hebrew word
function calculateBiblicalGematria(word, cipher) {
  let total = 0;
  for (const char of word) {
    if (cipher[char]) {
      total += cipher[char];
    }
  }
  return total;
}

// Example: Calculate gematria of "בראשית" (In the beginning)
// ב=2, ר=200, א=1, ש=3, י=10, ת=4
// Result: 2 + 200 + 1 + 3 + 10 + 4 = 220
const bereshit = "בראשית";
const value = calculateBiblicalGematria(bereshit, biblicalCipher);
console.log(`${bereshit} = ${value}`); // בראשית = 220
```

--------------------------------

### CSS Styling for Tanakh Gematria Reader

Source: https://github.com/wjbaker2025/hebrew-holy-tanakh/blob/main/bible_app.html

This CSS code defines the visual appearance of the Tanakh Gematria Reader. It sets up a dark theme with specific colors for background, text, sidebar, and highlights. It also styles elements like the sidebar, main content area, top bar, search input, buttons, verse display, and word cards, including a special style for imprinted words.

```css
:root {
  --bg-color: #1e1e1e;
  --text-color: #e0e0e0;
  --sidebar-width: 250px;
  --accent-color: #0078d4; /* Windows 11 Blue */
  --highlight-color: #ffd700;
  --highlight-text: #000;
}
body {
  margin: 0;
  font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
  background-color: var(--bg-color);
  color: var(--text-color);
  display: flex;
  height: 100vh;
  overflow: hidden;
}
/* Sidebar - Books */
#sidebar {
  width: var(--sidebar-width);
  background-color: #252526;
  border-right: 1px solid #333;
  display: flex;
  flex-direction: column;
  overflow-y: auto;
}
.tab-header {
  padding: 15px;
  font-weight: bold;
  background-color: #2d2d2d;
  border-bottom: 1px solid #333;
  text-transform: uppercase;
  letter-spacing: 1px;
}
.book-list {
  list-style: none;
  padding: 0;
  margin: 0;
}
.book-item {
  padding: 10px 15px;
  cursor: pointer;
  border-bottom: 1px solid #2d2d2d;
  transition: background 0.2s;
}
.book-item:hover, .book-item.active {
  background-color: #37373d;
  border-left: 4px solid var(--accent-color);
}
/* Main Content */
#main-content {
  flex: 1;
  display: flex;
  flex-direction: column;
  height: 100%;
}
/* Top Bar - Gematria Tools */
#top-bar {
  height: 70px;
  background-color: #2d2d2d;
  border-bottom: 1px solid #333;
  display: flex;
  align-items: center;
  padding: 0 20px;
  gap: 15px;
  box-shadow: 0 2px 5px rgba(0,0,0,0.2);
}
.search-group {
  display: flex;
  gap: 10px;
  flex: 1;
  max-width: 600px;
}
input[type="text"] {
  flex: 1;
  padding: 8px 12px;
  border-radius: 4px;
  border: 1px solid #444;
  background-color: #1e1e1e;
  color: white;
  font-size: 14px;
}
button {
  padding: 8px 16px;
  background-color: var(--accent-color);
  color: white;
  border: none;
  border-radius: 4px;
  cursor: pointer;
  font-weight: 500;
}
button:hover {
  opacity: 0.9;
}
.gematria-display {
  font-family: 'Courier New', monospace;
  font-size: 14px;
  color: #aaa;
}
.gematria-value {
  color: var(--highlight-color);
  font-weight: bold;
}
/* Reader Area */
#reader-container {
  flex: 1;
  overflow-y: auto;
  padding: 20px 40px;
  scroll-behavior: smooth;
}
/* Navigation Controls */
#nav-controls {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 10px 40px;
  background-color: #252526;
  border-top: 1px solid #333;
}
/* Bible Text Layout */
.chapter-title {
  font-size: 2em;
  margin-bottom: 20px;
  border-bottom: 1px solid #444;
  padding-bottom: 10px;
}
.verse-container {
  margin-bottom: 25px;
  display: flex;
  flex-wrap: wrap;
  align-items: flex-start;
  gap: 15px;
  line-height: 1.6;
}
.verse-number {
  font-weight: bold;
  color: var(--accent-color);
  margin-right: 5px;
  font-size: 0.9em;
  user-select: none;
}
/* Word Cards */
.word-card {
  display: flex;
  flex-direction: column;
  align-items: center;
  padding: 4px;
  border-radius: 4px;
  transition: background 0.2s;
}
.word-hebrew {
  font-family: 'Ezra SIL', 'Times New Roman', serif;
  font-size: 1.4em;
  direction: rtl;
  margin-bottom: 2px;
}
.word-english {
  font-size: 0.85em;
  color: #aaa;
  text-align: center;
}
/* Highlighting Logic */
.word-card.imprinted {
  background-color: var(--highlight-color);
}
.word-card.imprinted .word-english {
  color: var(--highlight-text);
  font-weight: bold;
}
.word-card.imprinted .word-hebrew {
  color: var(--highlight-text);
}
```

--------------------------------

### Greek Transposition Cipher Definition (JavaScript)

Source: https://context7.com/wjbaker2025/hebrew-holy-tanakh/llms.txt

Defines the Greek Transposition Cipher, mapping Hebrew letters to Greek equivalents for New Testament analysis. It includes the cipher mapping and a list of Greek letters with their Hebrew counterparts.

```javascript
const greekTransposition = {
  "α": 1,   "β": 2,   "γ": 3,   "τ": 3,   "δ": 4,   "υ": 4,
  "ε": 5,   "Ϝ": 6,   "ζ": 7,   "η": 8,   "θ": 9,   "ι": 10,
  "κ": 20,  "φ": 20,  "λ": 30,  "μ": 40,  "χ": 40,  "ν": 50,
  "ψ": 50,  "ξ": 60,  "ο": 70,  "π": 80,  "ω": 80,  "ϙ": 90,
  "ϡ": 90,  "ρ": 100, "ς": 200
};

// Greek letters with Hebrew equivalents
const greekLetters = [
  { letter: "α", name: "Alpha", biblical: 1, hebrew: "א" },
  { letter: "β", name: "Beta", biblical: 2, hebrew: "ב" },
  { letter: "γ", name: "Gamma", biblical: 3, hebrew: "ג" },
  { letter: "δ", name: "Delta", biblical: 4, hebrew: "ד" },
  { letter: "τ", name: "Tau", biblical: 3, hebrew: "ש" },    // Shin equivalent
  { letter: "υ", name: "Upsilon", biblical: 4, hebrew: "ת" } // Tav equivalent
]
```

--------------------------------

### JavaScript Gematria Calculation

Source: https://github.com/wjbaker2025/hebrew-holy-tanakh/blob/main/bible_app.html

Implements a gematria calculation function using a predefined map of Hebrew characters to their numerical values. It sums the values of known Hebrew characters in a given text.

```javascript
// --- 2. GEMATRIA ENGINE ---
// Simple mapping based on your definition file (Biblical Cipher)
const gematriaMap = {
  'א':1, 'ב':2, 'ג':3, 'ש':3, 'ד':4, 'ת':4, 'ה':5, 'ו':6, 'ז':7, 'ח':8, 'ט':9, 'י':10, 'כ':20, 'ך':20, 'ל':30, 'מ':40, 'ם':40, 'נ':50, 'ן':50, 'ס':60, 'ע':70, 'פ':80, 'ף':80, 'צ':90, 'ץ':90, 'ק':100, 'ר':200
};

function calculateGematria(text) {
  if (!text) return 0;
  // Clean non-hebrew chars usually, but here we just sum known chars
  let sum = 0;
  for (let char of text) {
    if (gematriaMap[char]) {
      sum += gematriaMap[char];
    }
  }
  return sum;
}

```
Tokens:
Raw