jyotish-calc 1.2.0 → 1.3.0

package/src/panchanga/vaara.js

@@ -0,0 +1,182 @@
+/**
+ * Vaara (Weekday) Calculations
+ * Simple weekday calculation from Julian Day
+ * 
+ * IMPORTANT: Vedic day runs from sunrise to sunrise, not midnight to midnight.
+ * Use vedicVaara() for panchanga calculations.
+ */
+
+const utils = require('./utils');
+const { VAARA_NAMES, VAARA_NAMES_SANSKRIT, KALI_YUGA_JD } = require('./constants');
+
+/**
+ * Get weekday for Julian Day (Gregorian - midnight to midnight)
+ * @param {number} jd - Julian Day Number
+ * @param {boolean} useAhargana - Use traditional Ahargana method (default: false)
+ * @returns {object} Weekday details
+ */
+function vaara(jd, useAhargana = false) {
+    let dayIndex;
+
+    if (useAhargana) {
+        // Traditional method using days since Kali Yuga
+        const ahargana = jd - KALI_YUGA_JD;
+        dayIndex = ((Math.floor(ahargana) % 7) + 5) % 7;
+    } else {
+        // Standard method
+        dayIndex = Math.floor(jd + 1.5) % 7;
+    }
+
+    return {
+        number: dayIndex,
+        name: VAARA_NAMES[dayIndex],
+        nameSanskrit: VAARA_NAMES_SANSKRIT[dayIndex],
+        planetaryRuler: getPlanetaryRuler(dayIndex)
+    };
+}
+
+/**
+ * Get VEDIC weekday (sunrise to sunrise based)
+ * In Vedic astrology, the day begins at sunrise.
+ * If time is before sunrise, the previous day's vaara applies.
+ * 
+ * @param {number} jd - Julian Day Number (local time)
+ * @param {object} place - {latitude, longitude, timezone}
+ * @param {object} sunriseData - Optional pre-calculated sunrise data
+ * @returns {object} Vedic weekday details with sunrise info
+ */
+function vedicVaara(jd, place, sunriseData = null) {
+    // Get sunrise for this date
+    const sunriseSunset = require('./sunrise-sunset');
+
+    const { year, month, day, hour } = utils.jdToDate(jd);
+    const currentTime = hour;
+
+    // Calculate sunrise for today
+    const todaySunrise = sunriseData || sunriseSunset.sunrise(jd, place);
+
+    let effectiveJD = jd;
+    let isBeforeSunrise = false;
+
+    // If current time is before sunrise, use previous day's vaara
+    if (todaySunrise && currentTime < todaySunrise.hours) {
+        isBeforeSunrise = true;
+        effectiveJD = jd - 1; // Use previous day
+    }
+
+    // Get the Gregorian weekday for the effective date
+    const dayIndex = Math.floor(effectiveJD + 1.5) % 7;
+
+    // Get the previous day's sunrise (which is the start of this Vedic day)
+    let vedicDaySunrise;
+    if (isBeforeSunrise) {
+        vedicDaySunrise = sunriseSunset.sunrise(jd - 1, place);
+    } else {
+        vedicDaySunrise = todaySunrise;
+    }
+
+    return {
+        number: dayIndex,
+        name: VAARA_NAMES[dayIndex],
+        nameSanskrit: VAARA_NAMES_SANSKRIT[dayIndex],
+        planetaryRuler: getPlanetaryRuler(dayIndex),
+        isBeforeSunrise,
+        vedicDate: isBeforeSunrise ? {
+            year: utils.jdToDate(effectiveJD).year,
+            month: utils.jdToDate(effectiveJD).month,
+            day: Math.floor(utils.jdToDate(effectiveJD).day)
+        } : { year, month, day: Math.floor(day) },
+        sunrise: vedicDaySunrise
+    };
+}
+
+/**
+ * Get planetary ruler of the weekday
+ * @param {number} dayIndex - Weekday index (0=Sunday)
+ * @returns {object} {planet, index}
+ */
+function getPlanetaryRuler(dayIndex) {
+    // Sun=0, Moon=1, Mars=2, Mercury=3, Jupiter=4, Venus=5, Saturn=6
+    const rulers = [
+        { name: 'Sun', index: 0 },
+        { name: 'Moon', index: 1 },
+        { name: 'Mars', index: 2 },
+        { name: 'Mercury', index: 3 },
+        { name: 'Jupiter', index: 4 },
+        { name: 'Venus', index: 5 },
+        { name: 'Saturn', index: 6 }
+    ];
+    return rulers[dayIndex];
+}
+
+/**
+ * Check if it's a specific weekday
+ * @param {number} jd - Julian Day Number
+ * @param {number|string} day - Day index or name
+ * @returns {boolean} True if matches
+ */
+function isWeekday(jd, day) {
+    const v = vaara(jd);
+    if (typeof day === 'number') {
+        return v.number === day;
+    }
+    return v.name.toLowerCase() === day.toLowerCase() ||
+        v.nameSanskrit.toLowerCase() === day.toLowerCase();
+}
+
+/**
+ * Find next occurrence of a specific weekday
+ * @param {number} jd - Starting Julian Day
+ * @param {number} targetDay - Target weekday (0-6)
+ * @returns {number} Julian Day of next occurrence
+ */
+function nextWeekday(jd, targetDay) {
+    const current = vaara(jd).number;
+    let daysToAdd = targetDay - current;
+    if (daysToAdd <= 0) daysToAdd += 7;
+    return jd + daysToAdd;
+}
+
+/**
+ * Find previous occurrence of a specific weekday
+ * @param {number} jd - Starting Julian Day
+ * @param {number} targetDay - Target weekday (0-6)
+ * @returns {number} Julian Day of previous occurrence
+ */
+function previousWeekday(jd, targetDay) {
+    const current = vaara(jd).number;
+    let daysToSubtract = current - targetDay;
+    if (daysToSubtract <= 0) daysToSubtract += 7;
+    return jd - daysToSubtract;
+}
+
+/**
+ * Get day quality based on planetary rulership
+ * @param {number} dayIndex - Weekday index
+ * @returns {string} Quality description
+ */
+function dayQuality(dayIndex) {
+    const qualities = {
+        0: 'Authority, government matters, health',     // Sunday
+        1: 'Mind, emotions, travel, water activities',  // Monday
+        2: 'Courage, conflict, property matters',       // Tuesday
+        3: 'Communication, learning, commerce',         // Wednesday
+        4: 'Wisdom, spirituality, ceremonies',          // Thursday
+        5: 'Love, arts, luxury, entertainment',         // Friday
+        6: 'Discipline, labor, service, agriculture'    // Saturday
+    };
+    return qualities[dayIndex];
+}
+
+module.exports = {
+    vaara,
+    vedicVaara,
+    getPlanetaryRuler,
+    isWeekday,
+    nextWeekday,
+    previousWeekday,
+    dayQuality,
+    VAARA_NAMES,
+    VAARA_NAMES_SANSKRIT
+};
+

package/src/panchanga/yogam.js

@@ -0,0 +1,196 @@
+/**
+ * Yogam (Sun-Moon Yoga) Calculations
+ * Yoga = ceil((Sun longitude + Moon longitude) / 13.333)
+ * 27 yogas from Vishkambha to Vaidhriti
+ */
+
+const sunriseSunset = require('./sunrise-sunset');
+const utils = require('./utils');
+const { YOGA_NAMES, ONE_YOGA } = require('./constants');
+
+/**
+ * Calculate yoga phase angle (Sun + Moon)
+ * @param {number} jdUTC - Julian Day (UTC)
+ * @returns {number} Combined angle (0-360)
+ */
+function yogaPhase(jdUTC) {
+    const sunLong = sunriseSunset.solarLongitude(jdUTC);
+    const moonLong = sunriseSunset.lunarLongitude(jdUTC);
+    return utils.norm360(sunLong + moonLong);
+}
+
+/**
+ * Calculate yoga number from phase
+ * @param {number} phase - Combined Sun+Moon angle
+ * @returns {number} Yoga number (1-27)
+ */
+function yogaFromPhase(phase) {
+    return Math.ceil(phase / ONE_YOGA) || 27;
+}
+
+/**
+ * Get yoga details for given date/time
+ * @param {number} jd - Julian Day Number (local)
+ * @param {object} place - {latitude, longitude, timezone}
+ * @returns {object} Yoga details
+ */
+function yogam(jd, place) {
+    const jdUTC = utils.toUTC(jd, place.timezone);
+    const rise = sunriseSunset.sunrise(jd, place);
+
+    if (!rise) return null;
+
+    const riseJDUTC = utils.toUTC(rise.jd, place.timezone);
+
+    // Get yoga at sunrise
+    const phase = yogaPhase(riseJDUTC);
+    const yogaNo = yogaFromPhase(phase);
+    const degreesLeft = yogaNo * ONE_YOGA - phase;
+
+    // Calculate combined motion at intervals
+    const offsets = [0.0, 0.25, 0.5, 0.75, 1.0];
+    const sunDiffs = offsets.map(t => {
+        return utils.norm360(sunriseSunset.solarLongitude(riseJDUTC + t) - sunriseSunset.solarLongitude(riseJDUTC));
+    });
+    const moonDiffs = offsets.map(t => {
+        return utils.norm360(sunriseSunset.lunarLongitude(riseJDUTC + t) - sunriseSunset.lunarLongitude(riseJDUTC));
+    });
+    const totalMotion = sunDiffs.map((s, i) => utils.norm360(s + moonDiffs[i]));
+
+    // Find when yoga ends
+    let endTime;
+    try {
+        const jdAtStart = utils.dateToJD(
+            utils.jdToDate(jd).year,
+            utils.jdToDate(jd).month,
+            utils.jdToDate(jd).day
+        );
+        const approxEnd = utils.inverseLagrange(offsets, totalMotion, degreesLeft);
+        endTime = (rise.jd + approxEnd - jdAtStart) * 24;
+    } catch {
+        // Fallback using average combined motion (~14 degrees/day)
+        const avgCombinedMotion = 14.0;
+        endTime = rise.hours + (degreesLeft / avgCombinedMotion) * 24;
+    }
+
+    // Get start time from previous day
+    const prevYoga = _getYogaAtSunrise(jd - 1, place);
+    let startTime = prevYoga ? prevYoga.endTime : rise.hours;
+    if (startTime > 24) startTime -= 24;
+    if (startTime < 0) startTime = -startTime;
+
+    // Check for yoga change during day
+    let nextYoga = null;
+    if (endTime < 24) {
+        const nextYogaNo = (yogaNo % 27) + 1;
+        nextYoga = {
+            number: nextYogaNo,
+            name: YOGA_NAMES[nextYogaNo - 1],
+            startTime: endTime
+        };
+    }
+
+    // Determine if yoga is auspicious
+    const auspicious = isAuspiciousYoga(yogaNo);
+
+    const result = {
+        number: yogaNo,
+        name: YOGA_NAMES[yogaNo - 1],
+        startTime,
+        endTime,
+        startTimeString: utils.formatTime(startTime < 0 ? startTime + 24 : startTime),
+        endTimeString: utils.formatTime(endTime > 24 ? endTime - 24 : endTime) + (endTime > 24 ? ' (+1)' : ''),
+        degreesLeft,
+        auspicious,
+        yogaPhase: phase
+    };
+
+    if (nextYoga) {
+        result.nextYoga = nextYoga;
+    }
+
+    return result;
+}
+
+/**
+ * Internal helper to get yoga at sunrise
+ */
+function _getYogaAtSunrise(jd, place) {
+    const rise = sunriseSunset.sunrise(jd, place);
+    if (!rise) return null;
+
+    const riseJDUTC = utils.toUTC(rise.jd, place.timezone);
+    const phase = yogaPhase(riseJDUTC);
+    const yogaNo = yogaFromPhase(phase);
+    const degreesLeft = yogaNo * ONE_YOGA - phase;
+
+    const offsets = [0.0, 0.25, 0.5, 0.75, 1.0];
+    const sunDiffs = offsets.map(t => {
+        return utils.norm360(sunriseSunset.solarLongitude(riseJDUTC + t) - sunriseSunset.solarLongitude(riseJDUTC));
+    });
+    const moonDiffs = offsets.map(t => {
+        return utils.norm360(sunriseSunset.lunarLongitude(riseJDUTC + t) - sunriseSunset.lunarLongitude(riseJDUTC));
+    });
+    const totalMotion = sunDiffs.map((s, i) => utils.norm360(s + moonDiffs[i]));
+
+    try {
+        const jdAtStart = utils.dateToJD(
+            utils.jdToDate(jd).year,
+            utils.jdToDate(jd).month,
+            utils.jdToDate(jd).day
+        );
+        const approxEnd = utils.inverseLagrange(offsets, totalMotion, degreesLeft);
+        const endTime = (rise.jd + approxEnd - jdAtStart) * 24;
+        return { yogaNo, endTime };
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Check if yoga is auspicious
+ * Auspicious: 2(Priti), 3(Ayushman), 4(Saubhagya), 5(Shobhana), 7(Sukarma), 
+ *             8(Dhriti), 11(Vriddhi), 12(Dhruva), 14(Harshana), 16(Siddhi),
+ *             18(Variyan), 20(Shiva), 21(Siddha), 22(Sadhya), 23(Shubha),
+ *             24(Shukla), 25(Brahma), 26(Indra)
+ * @param {number} yogaNo - Yoga number (1-27)
+ * @returns {boolean} True if auspicious
+ */
+function isAuspiciousYoga(yogaNo) {
+    const auspiciousYogas = [2, 3, 4, 5, 7, 8, 11, 12, 14, 16, 18, 20, 21, 22, 23, 24, 25, 26];
+    return auspiciousYogas.includes(yogaNo);
+}
+
+/**
+ * Check if yoga is inauspicious (Vishkambha, Atiganda, Shoola, Ganda, Vyaghata, Vajra, Vyatipata, Parigha, Vaidhriti)
+ * @param {number} yogaNo - Yoga number (1-27)
+ * @returns {boolean} True if inauspicious
+ */
+function isInauspiciousYoga(yogaNo) {
+    const inauspiciousYogas = [1, 6, 9, 10, 13, 15, 17, 19, 27];
+    return inauspiciousYogas.includes(yogaNo);
+}
+
+/**
+ * Quick yoga lookup
+ * @param {number} jdUTC - Julian Day (UTC)
+ * @returns {object} {yoga, name}
+ */
+function quickYoga(jdUTC) {
+    const phase = yogaPhase(jdUTC);
+    const yogaNo = yogaFromPhase(phase);
+    return {
+        number: yogaNo,
+        name: YOGA_NAMES[yogaNo - 1]
+    };
+}
+
+module.exports = {
+    yogam,
+    yogaPhase,
+    yogaFromPhase,
+    quickYoga,
+    isAuspiciousYoga,
+    isInauspiciousYoga,
+    YOGA_NAMES
+};

package/get-full-results.js

@@ -1,140 +0,0 @@
-/**
- * Complete Package Result Export
- * Birth Chart: Sep 11, 1998, 4:30 AM, Chennai
- */
-
-const jyotish = require('./index');
-
-const birthData = {
-    dateString: '1998-09-11',
-    timeString: '04:30:00',
-    lat: 13.0827,
-    lng: 80.2707,
-    timezone: 5.5
-};
-
-const planetMap = {
-    'Su': 'Sun', 'Mo': 'Moon', 'Ma': 'Mars', 'Me': 'Mercury',
-    'Ju': 'Jupiter', 'Ve': 'Venus', 'Sa': 'Saturn', 'Ra': 'Rahu', 'Ke': 'Ketu',
-    'La': 'Ascendant'
-};
-
-async function getFullResults() {
-    const results = {};
-
-    try {
-        // 1. GRAHA POSITIONS
-        results.positions = jyotish.grahas.getGrahasPosition(birthData);
-
-        // Prepare data for other modules
-        const moonLong = results.positions.Mo.longitude;
-        const lagnaLong = results.positions.La.longitude;
-        const planetLongitudes = {};
-        const shadbalaPositions = [];
-        const shadbalaOrder = ['Su', 'Mo', 'Ma', 'Me', 'Ju', 'Ve', 'Sa'];
-
-        Object.entries(results.positions).forEach(([key, p]) => {
-            if (planetMap[key]) planetLongitudes[planetMap[key]] = p.longitude;
-        });
-
-        shadbalaOrder.forEach(key => {
-            const p = results.positions[key];
-            shadbalaPositions.push([Math.floor(p.longitude / 30), p.longitude % 30]);
-        });
-
-        // Extract birth date/time components
-        const [year, month, date] = birthData.dateString.split('-').map(Number);
-        const [hour, min, sec] = birthData.timeString.split(':').map(Number);
-
-        // 2. SPECIAL LAGNAS
-        const lagnaBirthData = {
-            year, month, date,
-            hour, min, sec,
-            lat: birthData.lat,
-            lng: birthData.lng,
-            timezone: birthData.timezone,
-            ayanamsha: 1
-        };
-        results.specialLagnas = jyotish.lagnas.calculateAllSpecialLagnas(lagnaBirthData);
-
-        // Add special lagnas to planet longitudes for varga calculation
-        Object.entries(results.specialLagnas).forEach(([name, data]) => {
-            planetLongitudes[name] = data.longitude;
-        });
-
-        // 3. UPAGRAHAS
-        results.upagrahas = jyotish.upagrahas.calculateAllUpagrahas(lagnaBirthData, results.positions);
-
-        // Add upagrahas to planet longitudes for varga calculation
-        Object.entries(results.upagrahas).forEach(([name, data]) => {
-            planetLongitudes[name] = data.longitude;
-        });
-
-        // 4. DASHAS (All Active Dashas)
-        const birthDateObj = new Date(birthData.dateString);
-        const checkDateObj = new Date();
-        results.dashas = jyotish.dashas.getAllActiveDashas(
-            birthDateObj,
-            moonLong,
-            lagnaLong,
-            checkDateObj,
-            planetLongitudes
-        );
-
-        // 5. VARGAS (Complete Portfolio for all standard divisions)
-        // Now includes special lagnas and upagrahas
-        results.vargas = {};
-        const vargaList = jyotish.vargas.getSupportedVargas(); // D1, D2, ..., D60
-        vargaList.forEach(vId => {
-            results.vargas[vId] = jyotish.vargas.calculateVargaChart(planetLongitudes, vId);
-        });
-
-        // 6. STRENGTHS (Shadbala & Bhavabala)
-        const localHourDecimal = hour + min / 60;
-        const utHourDecimal = localHourDecimal - birthData.timezone;
-        const jdUT = jyotish.strengths.julianDayNumber(
-            [year, month, date],
-            [Math.floor(utHourDecimal), (utHourDecimal % 1) * 60, 0]
-        );
-
-        results.strengths = {
-            shadbala: jyotish.strengths.calculateShadbala(
-                shadbalaPositions,
-                Math.floor(lagnaLong / 30),
-                jdUT,
-                birthData.lat,
-                birthData.lng
-            ),
-            bhavabala: jyotish.strengths.calculateBhavaBala(
-                shadbalaPositions,
-                Math.floor(lagnaLong / 30),
-                jdUT,
-                birthData.lat,
-                birthData.lng
-            )
-        };
-
-        // 7. ASHTAKAVARGA (BAV & SAV)
-        const ashtakavargaPositions = {
-            Sun: results.positions.Su.longitude,
-            Moon: results.positions.Mo.longitude,
-            Mars: results.positions.Ma.longitude,
-            Mercury: results.positions.Me.longitude,
-            Jupiter: results.positions.Ju.longitude,
-            Venus: results.positions.Ve.longitude,
-            Saturn: results.positions.Sa.longitude,
-            Ascendant: results.positions.La.longitude
-        };
-        results.ashtakavarga = jyotish.ashtakavarga.calculateDetailedAshtakavarga(ashtakavargaPositions);
-
-        // Write to file directly
-        const fs = require('fs');
-        fs.writeFileSync('results.json', JSON.stringify(results, null, 2), 'utf8');
-        console.log('Results written to results.json');
-
-    } catch (err) {
-        console.error(JSON.stringify({ error: err.message, stack: err.stack }, null, 2));
-    }
-}
-
-getFullResults();

package/test-chennai-1998.js

@@ -1,162 +0,0 @@
-/**
- * Test script for Birth Chart: Sep 11, 1998, 4:30 AM, Chennai
- */
-
-const jyotish = require('./index');
-
-// ============================================================================
-// BIRTH DATA
-// ============================================================================
-const birthData = {
-    dateString: '1998-09-11', // YYYY-MM-DD
-    timeString: '04:30:00',   // HH:MM:SS
-    lat: 13.0827,
-    lng: 80.2707,
-    timezone: 5.5
-};
-
-console.log('================================================================');
-console.log('  BIRTH CHART ANALYSIS');
-console.log('================================================================');
-console.log(`Date: ${birthData.dateString}, ${birthData.timeString}`);
-console.log(`Location: Chennai (${birthData.lat}° N, ${birthData.lng}° E)`);
-console.log('----------------------------------------------------------------\n');
-
-(async () => {
-    try {
-        // 1. Calculate Planetary Positions
-        console.log('Calculated Positions...');
-        const positions = jyotish.grahas.getGrahasPosition(birthData);
-
-        console.log('PLANETARY POSITIONS (D1 Rashi):');
-        console.log('-------------------------------');
-
-        const rashiNames = [
-            'Aries', 'Taurus', 'Gemini', 'Cancer', 'Leo', 'Virgo',
-            'Libra', 'Scorpio', 'Sagittarius', 'Capricorn', 'Aquarius', 'Pisces'
-        ];
-
-        const planetMap = {
-            'Su': 'Sun', 'Mo': 'Moon', 'Ma': 'Mars', 'Me': 'Mercury',
-            'Ju': 'Jupiter', 'Ve': 'Venus', 'Sa': 'Saturn', 'Ra': 'Rahu', 'Ke': 'Ketu',
-            'La': 'Ascendant'
-        };
-
-        const shadbalaPositions = [];
-        const planetLongitudes = {};
-        const shadbalaOrder = ['Su', 'Mo', 'Ma', 'Me', 'Ju', 'Ve', 'Sa'];
-
-        // Process Ascendant
-        if (positions.La) {
-            const asc = positions.La;
-            const signIndex = Math.floor(asc.longitude / 30);
-            const degree = asc.longitude % 30;
-            console.log(`Ascendant : ${rashiNames[signIndex].padEnd(12)} ${degree.toFixed(2)}°`);
-        }
-
-        // Process Planets
-        shadbalaOrder.forEach(key => {
-            const p = positions[key];
-            const name = planetMap[key];
-            if (p) {
-                const signIndex = Math.floor(p.longitude / 30);
-                const degree = p.longitude % 30;
-
-                planetLongitudes[name] = p.longitude;
-                shadbalaPositions.push([signIndex, degree]);
-
-                console.log(`${name.padEnd(10)}: ${rashiNames[signIndex].padEnd(12)} ${degree.toFixed(2)}°`);
-            }
-        });
-
-        ['Ra', 'Ke'].forEach(key => {
-            if (positions[key]) {
-                const p = positions[key];
-                const name = planetMap[key];
-                const signIndex = Math.floor(p.longitude / 30);
-                const degree = p.longitude % 30;
-                planetLongitudes[name] = p.longitude;
-                console.log(`${name.padEnd(10)}: ${rashiNames[signIndex].padEnd(12)} ${degree.toFixed(2)}°`);
-            }
-        });
-
-        console.log('\n');
-
-        // 2. Navamsha (D9)
-        console.log('NAVAMSHA CHART (D9):');
-        console.log('--------------------');
-        try {
-            const d9Chart = jyotish.vargas.calculateVargaChart(planetLongitudes, 'D9', { abbrev: false });
-            shadbalaOrder.concat(['Ra', 'Ke']).forEach(key => {
-                const name = planetMap[key];
-                const val = d9Chart[name];
-                const display = (typeof val === 'object' && val.sign) ? val.sign : val;
-                console.log(`${name.padEnd(10)}: ${display}`);
-            });
-        } catch (e) {
-            console.log('Error calculating Navamsha:', e.message);
-        }
-        console.log('\n');
-
-        // 3. Current Dasha (Vimshottari)
-        console.log('CURRENT VIMSHOTTARI DASHA:');
-        console.log('--------------------------');
-        try {
-            const moonLong = positions.Mo.longitude;
-            const checkDateObj = new Date();
-            const birthDateObj = new Date(birthData.dateString);
-
-            const currentDasha = jyotish.dashas.vimshottari.getDashasForDate(birthDateObj, moonLong, checkDateObj);
-
-            const checkDateStr = checkDateObj.toISOString().split('T')[0];
-            console.log(`Current Date: ${checkDateStr}`);
-            // Use endDate instead of end
-            console.log(`Mahadasha:       ${currentDasha.mahadasha.lord} (ends ${currentDasha.mahadasha.endDate ? new Date(currentDasha.mahadasha.endDate).toLocaleDateString() : 'N/A'})`);
-            console.log(`Antardasha:      ${currentDasha.antardasha.lord} (ends ${currentDasha.antardasha.endDate ? new Date(currentDasha.antardasha.endDate).toLocaleDateString() : 'N/A'})`);
-            console.log(`Pratyantardasha: ${currentDasha.pratyantardasha.lord} (ends ${currentDasha.pratyantardasha.endDate ? new Date(currentDasha.pratyantardasha.endDate).toLocaleDateString() : 'N/A'})`);
-        } catch (e) {
-            console.log('Error calculating Dasha:', e.message);
-        }
-
-        // 4. Shadbala Strength
-        console.log('\nSHADBALA STRENGTHS:');
-        console.log('-------------------');
-        try {
-            const [year, month, date] = birthData.dateString.split('-').map(Number);
-            const [hour, min, sec] = birthData.timeString.split(':').map(Number);
-
-            const localHourDecimal = hour + min / 60;
-            const utHourDecimal = localHourDecimal - birthData.timezone;
-
-            const jdUT = jyotish.strengths.julianDayNumber(
-                [year, month, date],
-                [Math.floor(utHourDecimal), (utHourDecimal % 1) * 60, 0]
-            );
-
-            const ascSignIndex = positions.La ? Math.floor(positions.La.longitude / 30) : 0;
-
-            const strengths = jyotish.strengths.calculateShadbala(
-                shadbalaPositions,
-                ascSignIndex,
-                jdUT,
-                birthData.lat,
-                birthData.lng
-            );
-
-            console.log('Planet     | Total (Virupas) | Ratio (Status)');
-            console.log('-----------|-----------------|---------------');
-            shadbalaOrder.forEach((key, i) => {
-                const name = planetMap[key];
-                const total = strengths.total[i].toFixed(1);
-                const ratio = strengths.strength[i].toFixed(2);
-                const status = strengths.strength[i] >= 1.0 ? 'Strong' : 'Weak';
-                console.log(`${name.padEnd(10)} | ${total.padStart(15)} | ${ratio} (${status})`);
-            });
-        } catch (e) {
-            console.log('Error calculating Strengths:', e.message);
-        }
-
-    } catch (err) {
-        console.error("Critical Error:", err);
-    }
-})();