@fin.cx/opendata 3.0.0 → 3.2.0

package/dist_ts/stocks/classes.stockdataservice.js

@@ -0,0 +1,495 @@
+import * as plugins from '../plugins.js';
+/**
+ * Unified service for managing both stock prices and fundamentals
+ * Provides automatic enrichment and convenient combined data access
+ */
+export class StockDataService {
+    constructor(config) {
+        this.priceProviders = new Map();
+        this.fundamentalsProviders = new Map();
+        this.priceCache = new Map();
+        this.fundamentalsCache = new Map();
+        this.logger = console;
+        this.config = {
+            cache: {
+                priceTTL: 24 * 60 * 60 * 1000, // 24 hours
+                fundamentalsTTL: 90 * 24 * 60 * 60 * 1000, // 90 days
+                maxEntries: 10000
+            },
+            timeout: {
+                price: 10000, // 10 seconds
+                fundamentals: 30000 // 30 seconds
+            }
+        };
+        if (config) {
+            this.config = {
+                cache: { ...this.config.cache, ...config.cache },
+                timeout: { ...this.config.timeout, ...config.timeout }
+            };
+        }
+    }
+    // ========== Provider Management ==========
+    /**
+     * Register a price provider
+     */
+    registerPriceProvider(provider, config) {
+        const defaultConfig = {
+            enabled: true,
+            priority: provider.priority,
+            timeout: this.config.timeout.price,
+            retryAttempts: 2,
+            retryDelay: 1000
+        };
+        const mergedConfig = { ...defaultConfig, ...config };
+        this.priceProviders.set(provider.name, {
+            provider,
+            config: mergedConfig,
+            successCount: 0,
+            errorCount: 0
+        });
+        console.log(`Registered price provider: ${provider.name}`);
+    }
+    /**
+     * Register a fundamentals provider
+     */
+    registerFundamentalsProvider(provider, config) {
+        const defaultConfig = {
+            enabled: true,
+            priority: provider.priority,
+            timeout: this.config.timeout.fundamentals,
+            retryAttempts: 2,
+            retryDelay: 1000,
+            cacheTTL: this.config.cache.fundamentalsTTL
+        };
+        const mergedConfig = { ...defaultConfig, ...config };
+        this.fundamentalsProviders.set(provider.name, {
+            provider,
+            config: mergedConfig,
+            successCount: 0,
+            errorCount: 0
+        });
+        console.log(`Registered fundamentals provider: ${provider.name}`);
+    }
+    /**
+     * Unregister a price provider
+     */
+    unregisterPriceProvider(providerName) {
+        this.priceProviders.delete(providerName);
+        console.log(`Unregistered price provider: ${providerName}`);
+    }
+    /**
+     * Unregister a fundamentals provider
+     */
+    unregisterFundamentalsProvider(providerName) {
+        this.fundamentalsProviders.delete(providerName);
+        console.log(`Unregistered fundamentals provider: ${providerName}`);
+    }
+    /**
+     * Get all registered price providers
+     */
+    getPriceProviders() {
+        return Array.from(this.priceProviders.values()).map(entry => entry.provider);
+    }
+    /**
+     * Get all registered fundamentals providers
+     */
+    getFundamentalsProviders() {
+        return Array.from(this.fundamentalsProviders.values()).map(entry => entry.provider);
+    }
+    /**
+     * Get enabled price providers sorted by priority
+     */
+    getEnabledPriceProviders() {
+        return Array.from(this.priceProviders.values())
+            .filter(entry => entry.config.enabled)
+            .sort((a, b) => (b.config.priority || 0) - (a.config.priority || 0))
+            .map(entry => entry.provider);
+    }
+    /**
+     * Get enabled fundamentals providers sorted by priority
+     */
+    getEnabledFundamentalsProviders() {
+        return Array.from(this.fundamentalsProviders.values())
+            .filter(entry => entry.config.enabled)
+            .sort((a, b) => (b.config.priority || 0) - (a.config.priority || 0))
+            .map(entry => entry.provider);
+    }
+    // ========== Data Fetching Methods ==========
+    /**
+     * Get current price for a single ticker
+     */
+    async getPrice(ticker) {
+        const cacheKey = `price:${ticker}`;
+        const cached = this.getFromCache(this.priceCache, cacheKey);
+        if (cached) {
+            console.log(`Cache hit for price: ${ticker}`);
+            return cached;
+        }
+        const providers = this.getEnabledPriceProviders();
+        if (providers.length === 0) {
+            throw new Error('No price providers available');
+        }
+        let lastError;
+        for (const provider of providers) {
+            const entry = this.priceProviders.get(provider.name);
+            try {
+                const result = await this.fetchWithRetry(() => provider.fetchData({ type: 'current', ticker }), entry.config);
+                entry.successCount++;
+                const price = result;
+                this.addToCache(this.priceCache, cacheKey, price, this.config.cache.priceTTL);
+                console.log(`Successfully fetched price for ${ticker} from ${provider.name}`);
+                return price;
+            }
+            catch (error) {
+                entry.errorCount++;
+                entry.lastError = error;
+                entry.lastErrorTime = new Date();
+                lastError = error;
+                console.warn(`Provider ${provider.name} failed for ${ticker}: ${error.message}`);
+            }
+        }
+        throw new Error(`Failed to fetch price for ${ticker} from all providers. Last error: ${lastError?.message}`);
+    }
+    /**
+     * Get current prices for multiple tickers
+     */
+    async getPrices(tickers) {
+        const cacheKey = `prices:${tickers.sort().join(',')}`;
+        const cached = this.getFromCache(this.priceCache, cacheKey);
+        if (cached) {
+            console.log(`Cache hit for prices: ${tickers.length} tickers`);
+            return cached;
+        }
+        const providers = this.getEnabledPriceProviders();
+        if (providers.length === 0) {
+            throw new Error('No price providers available');
+        }
+        let lastError;
+        for (const provider of providers) {
+            const entry = this.priceProviders.get(provider.name);
+            try {
+                const result = await this.fetchWithRetry(() => provider.fetchData({ type: 'batch', tickers }), entry.config);
+                entry.successCount++;
+                const prices = result;
+                this.addToCache(this.priceCache, cacheKey, prices, this.config.cache.priceTTL);
+                console.log(`Successfully fetched ${prices.length} prices from ${provider.name}`);
+                return prices;
+            }
+            catch (error) {
+                entry.errorCount++;
+                entry.lastError = error;
+                entry.lastErrorTime = new Date();
+                lastError = error;
+                console.warn(`Provider ${provider.name} failed for batch prices: ${error.message}`);
+            }
+        }
+        throw new Error(`Failed to fetch prices for ${tickers.length} tickers from all providers. Last error: ${lastError?.message}`);
+    }
+    /**
+     * Get fundamentals for a single ticker
+     */
+    async getFundamentals(ticker) {
+        const cacheKey = `fundamentals:${ticker}`;
+        const cached = this.getFromCache(this.fundamentalsCache, cacheKey);
+        if (cached) {
+            console.log(`Cache hit for fundamentals: ${ticker}`);
+            return cached;
+        }
+        const providers = this.getEnabledFundamentalsProviders();
+        if (providers.length === 0) {
+            throw new Error('No fundamentals providers available');
+        }
+        let lastError;
+        for (const provider of providers) {
+            const entry = this.fundamentalsProviders.get(provider.name);
+            try {
+                const result = await this.fetchWithRetry(() => provider.fetchData({ type: 'fundamentals-current', ticker }), entry.config);
+                entry.successCount++;
+                const fundamentals = result;
+                const ttl = entry.config.cacheTTL || this.config.cache.fundamentalsTTL;
+                this.addToCache(this.fundamentalsCache, cacheKey, fundamentals, ttl);
+                console.log(`Successfully fetched fundamentals for ${ticker} from ${provider.name}`);
+                return fundamentals;
+            }
+            catch (error) {
+                entry.errorCount++;
+                entry.lastError = error;
+                entry.lastErrorTime = new Date();
+                lastError = error;
+                console.warn(`Provider ${provider.name} failed for ${ticker} fundamentals: ${error.message}`);
+            }
+        }
+        throw new Error(`Failed to fetch fundamentals for ${ticker} from all providers. Last error: ${lastError?.message}`);
+    }
+    /**
+     * Get fundamentals for multiple tickers
+     */
+    async getBatchFundamentals(tickers) {
+        const cacheKey = `fundamentals-batch:${tickers.sort().join(',')}`;
+        const cached = this.getFromCache(this.fundamentalsCache, cacheKey);
+        if (cached) {
+            console.log(`Cache hit for batch fundamentals: ${tickers.length} tickers`);
+            return cached;
+        }
+        const providers = this.getEnabledFundamentalsProviders();
+        if (providers.length === 0) {
+            throw new Error('No fundamentals providers available');
+        }
+        let lastError;
+        for (const provider of providers) {
+            const entry = this.fundamentalsProviders.get(provider.name);
+            try {
+                const result = await this.fetchWithRetry(() => provider.fetchData({ type: 'fundamentals-batch', tickers }), entry.config);
+                entry.successCount++;
+                const fundamentals = result;
+                const ttl = entry.config.cacheTTL || this.config.cache.fundamentalsTTL;
+                this.addToCache(this.fundamentalsCache, cacheKey, fundamentals, ttl);
+                console.log(`Successfully fetched ${fundamentals.length} fundamentals from ${provider.name}`);
+                return fundamentals;
+            }
+            catch (error) {
+                entry.errorCount++;
+                entry.lastError = error;
+                entry.lastErrorTime = new Date();
+                lastError = error;
+                console.warn(`Provider ${provider.name} failed for batch fundamentals: ${error.message}`);
+            }
+        }
+        throw new Error(`Failed to fetch fundamentals for ${tickers.length} tickers from all providers. Last error: ${lastError?.message}`);
+    }
+    /**
+     * ✨ Get complete stock data (price + fundamentals) with automatic enrichment
+     */
+    async getStockData(request) {
+        const normalizedRequest = typeof request === 'string'
+            ? { ticker: request, includeFundamentals: true, enrichFundamentals: true }
+            : { includeFundamentals: true, enrichFundamentals: true, ...request };
+        const price = await this.getPrice(normalizedRequest.ticker);
+        let fundamentals;
+        if (normalizedRequest.includeFundamentals) {
+            try {
+                fundamentals = await this.getFundamentals(normalizedRequest.ticker);
+                // Enrich fundamentals with price calculations
+                if (normalizedRequest.enrichFundamentals && fundamentals) {
+                    fundamentals = this.enrichWithPrice(fundamentals, price.price);
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to fetch fundamentals for ${normalizedRequest.ticker}: ${error.message}`);
+                // Continue without fundamentals
+            }
+        }
+        return {
+            ticker: normalizedRequest.ticker,
+            price,
+            fundamentals,
+            fetchedAt: new Date()
+        };
+    }
+    /**
+     * ✨ Get complete stock data for multiple tickers with automatic enrichment
+     */
+    async getBatchStockData(request) {
+        const normalizedRequest = Array.isArray(request)
+            ? { tickers: request, includeFundamentals: true, enrichFundamentals: true }
+            : { includeFundamentals: true, enrichFundamentals: true, ...request };
+        const prices = await this.getPrices(normalizedRequest.tickers);
+        const priceMap = new Map(prices.map(p => [p.ticker, p]));
+        let fundamentalsMap = new Map();
+        if (normalizedRequest.includeFundamentals) {
+            try {
+                const fundamentals = await this.getBatchFundamentals(normalizedRequest.tickers);
+                // Enrich with prices if requested
+                if (normalizedRequest.enrichFundamentals) {
+                    for (const fund of fundamentals) {
+                        const price = priceMap.get(fund.ticker);
+                        if (price) {
+                            fundamentalsMap.set(fund.ticker, this.enrichWithPrice(fund, price.price));
+                        }
+                        else {
+                            fundamentalsMap.set(fund.ticker, fund);
+                        }
+                    }
+                }
+                else {
+                    fundamentalsMap = new Map(fundamentals.map(f => [f.ticker, f]));
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to fetch batch fundamentals: ${error.message}`);
+                // Continue without fundamentals
+            }
+        }
+        return normalizedRequest.tickers.map(ticker => ({
+            ticker,
+            price: priceMap.get(ticker),
+            fundamentals: fundamentalsMap.get(ticker),
+            fetchedAt: new Date()
+        }));
+    }
+    // ========== Helper Methods ==========
+    /**
+     * Enrich fundamentals with calculated metrics using current price
+     */
+    enrichWithPrice(fundamentals, price) {
+        const enriched = { ...fundamentals };
+        // Calculate market cap: price × shares outstanding
+        if (fundamentals.sharesOutstanding) {
+            enriched.marketCap = price * fundamentals.sharesOutstanding;
+        }
+        // Calculate P/E ratio: price / EPS
+        if (fundamentals.earningsPerShareDiluted && fundamentals.earningsPerShareDiluted > 0) {
+            enriched.priceToEarnings = price / fundamentals.earningsPerShareDiluted;
+        }
+        // Calculate price-to-book: market cap / stockholders equity
+        if (enriched.marketCap && fundamentals.stockholdersEquity && fundamentals.stockholdersEquity > 0) {
+            enriched.priceToBook = enriched.marketCap / fundamentals.stockholdersEquity;
+        }
+        return enriched;
+    }
+    /**
+     * Fetch with retry logic
+     */
+    async fetchWithRetry(fetchFn, config) {
+        const maxAttempts = config.retryAttempts || 1;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                return await fetchFn();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < maxAttempts) {
+                    const delay = (config.retryDelay || 1000) * attempt;
+                    console.log(`Retry attempt ${attempt} after ${delay}ms`);
+                    await plugins.smartdelay.delayFor(delay);
+                }
+            }
+        }
+        throw lastError || new Error('Unknown error during fetch');
+    }
+    /**
+     * Get from cache if not expired
+     */
+    getFromCache(cache, key) {
+        const entry = cache.get(key);
+        if (!entry) {
+            return null;
+        }
+        // Check if cache entry has expired
+        const age = Date.now() - entry.timestamp.getTime();
+        if (entry.ttl !== Infinity && age > entry.ttl) {
+            cache.delete(key);
+            return null;
+        }
+        return entry.data;
+    }
+    /**
+     * Add to cache with TTL
+     */
+    addToCache(cache, key, data, ttl) {
+        // Enforce max entries limit
+        if (cache.size >= this.config.cache.maxEntries) {
+            // Remove oldest entry
+            const oldestKey = cache.keys().next().value;
+            if (oldestKey) {
+                cache.delete(oldestKey);
+            }
+        }
+        cache.set(key, {
+            data,
+            timestamp: new Date(),
+            ttl
+        });
+    }
+    // ========== Health & Statistics ==========
+    /**
+     * Check health of all providers (both price and fundamentals)
+     */
+    async checkProvidersHealth() {
+        const health = new Map();
+        // Check price providers
+        for (const [name, entry] of this.priceProviders) {
+            if (!entry.config.enabled) {
+                health.set(`${name} (price)`, false);
+                continue;
+            }
+            try {
+                const isAvailable = await entry.provider.isAvailable();
+                health.set(`${name} (price)`, isAvailable);
+            }
+            catch (error) {
+                health.set(`${name} (price)`, false);
+                console.error(`Health check failed for ${name}:`, error);
+            }
+        }
+        // Check fundamentals providers
+        for (const [name, entry] of this.fundamentalsProviders) {
+            if (!entry.config.enabled) {
+                health.set(`${name} (fundamentals)`, false);
+                continue;
+            }
+            try {
+                const isAvailable = await entry.provider.isAvailable();
+                health.set(`${name} (fundamentals)`, isAvailable);
+            }
+            catch (error) {
+                health.set(`${name} (fundamentals)`, false);
+                console.error(`Health check failed for ${name}:`, error);
+            }
+        }
+        return health;
+    }
+    /**
+     * Get statistics for all providers
+     */
+    getProviderStats() {
+        const stats = new Map();
+        // Price provider stats
+        for (const [name, entry] of this.priceProviders) {
+            stats.set(name, {
+                type: 'price',
+                successCount: entry.successCount,
+                errorCount: entry.errorCount,
+                lastError: entry.lastError?.message,
+                lastErrorTime: entry.lastErrorTime
+            });
+        }
+        // Fundamentals provider stats
+        for (const [name, entry] of this.fundamentalsProviders) {
+            stats.set(name, {
+                type: 'fundamentals',
+                successCount: entry.successCount,
+                errorCount: entry.errorCount,
+                lastError: entry.lastError?.message,
+                lastErrorTime: entry.lastErrorTime
+            });
+        }
+        return stats;
+    }
+    /**
+     * Clear all caches
+     */
+    clearCache() {
+        this.priceCache.clear();
+        this.fundamentalsCache.clear();
+        console.log('All caches cleared');
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        return {
+            priceCache: {
+                size: this.priceCache.size,
+                ttl: this.config.cache.priceTTL
+            },
+            fundamentalsCache: {
+                size: this.fundamentalsCache.size,
+                ttl: this.config.cache.fundamentalsTTL
+            },
+            maxEntries: this.config.cache.maxEntries
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stockdataservice.js","sourceRoot":"","sources":["../../ts/stocks/classes.stockdataservice.ts"],"names":[],"mappings":"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"}

package/dist_ts/stocks/index.d.ts

@@ -1,5 +1,11 @@
 export * from './interfaces/stockprice.js';
 export * from './interfaces/provider.js';
+export * from './interfaces/fundamentals.js';
+export * from './interfaces/stockdata.js';
 export * from './classes.stockservice.js';
+export * from './classes.fundamentalsservice.js';
+export * from './classes.stockdataservice.js';
+export * from './classes.baseproviderservice.js';
 export * from './providers/provider.yahoo.js';
 export * from './providers/provider.marketstack.js';
+export * from './providers/provider.secedgar.js';

package/dist_ts/stocks/index.js

@@ -1,9 +1,16 @@
 // Export all interfaces
 export * from './interfaces/stockprice.js';
 export * from './interfaces/provider.js';
-// Export main service
+export * from './interfaces/fundamentals.js';
+export * from './interfaces/stockdata.js';
+// Export main services
 export * from './classes.stockservice.js';
+export * from './classes.fundamentalsservice.js';
+export * from './classes.stockdataservice.js'; // ✨ New unified service
+// Export base service (for advanced use cases)
+export * from './classes.baseproviderservice.js';
 // Export providers
 export * from './providers/provider.yahoo.js';
 export * from './providers/provider.marketstack.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9zdG9ja3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsd0JBQXdCO0FBQ3hCLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYywwQkFBMEIsQ0FBQztBQUV6QyxzQkFBc0I7QUFDdEIsY0FBYywyQkFBMkIsQ0FBQztBQUUxQyxtQkFBbUI7QUFDbkIsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHFDQUFxQyxDQUFDIn0=
+export * from './providers/provider.secedgar.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9zdG9ja3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsd0JBQXdCO0FBQ3hCLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsMkJBQTJCLENBQUM7QUFFMUMsdUJBQXVCO0FBQ3ZCLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLCtCQUErQixDQUFDLENBQUMsd0JBQXdCO0FBRXZFLCtDQUErQztBQUMvQyxjQUFjLGtDQUFrQyxDQUFDO0FBRWpELG1CQUFtQjtBQUNuQixjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxrQ0FBa0MsQ0FBQyJ9

package/dist_ts/stocks/interfaces/fundamentals.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Interfaces for stock fundamental data (financials from SEC filings)
+ * Separate from stock price data (OHLCV) to maintain clean architecture
+ */
+export interface IFundamentalsCurrentRequest {
+    type: 'fundamentals-current';
+    ticker: string;
+}
+export interface IFundamentalsBatchRequest {
+    type: 'fundamentals-batch';
+    tickers: string[];
+}
+export type IFundamentalsRequest = IFundamentalsCurrentRequest | IFundamentalsBatchRequest;
+/**
+ * Stock fundamental data from SEC filings (10-K, 10-Q)
+ * Contains financial metrics like EPS, Revenue, Assets, etc.
+ */
+export interface IStockFundamentals {
+    ticker: string;
+    cik: string;
+    companyName: string;
+    provider: string;
+    timestamp: Date;
+    fetchedAt: Date;
+    earningsPerShareBasic?: number;
+    earningsPerShareDiluted?: number;
+    sharesOutstanding?: number;
+    weightedAverageSharesOutstanding?: number;
+    revenue?: number;
+    netIncome?: number;
+    operatingIncome?: number;
+    grossProfit?: number;
+    costOfRevenue?: number;
+    assets?: number;
+    liabilities?: number;
+    stockholdersEquity?: number;
+    cash?: number;
+    propertyPlantEquipment?: number;
+    marketCap?: number;
+    priceToEarnings?: number;
+    priceToBook?: number;
+    fiscalYear?: string;
+    fiscalQuarter?: string;
+    filingDate?: Date;
+    form?: '10-K' | '10-Q' | string;
+}
+/**
+ * Provider interface for fetching fundamental data
+ * Parallel to IStockProvider but for fundamentals instead of prices
+ */
+export interface IFundamentalsProvider {
+    name: string;
+    priority: number;
+    fetchData(request: IFundamentalsRequest): Promise<IStockFundamentals | IStockFundamentals[]>;
+    isAvailable(): Promise<boolean>;
+    readonly requiresAuth: boolean;
+    readonly rateLimit?: {
+        requestsPerMinute: number;
+        requestsPerDay?: number;
+    };
+}
+/**
+ * Configuration for fundamentals providers
+ */
+export interface IFundamentalsProviderConfig {
+    enabled: boolean;
+    priority?: number;
+    timeout?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+    cacheTTL?: number;
+}
+/**
+ * Registry for managing fundamental data providers
+ */
+export interface IFundamentalsProviderRegistry {
+    register(provider: IFundamentalsProvider, config?: IFundamentalsProviderConfig): void;
+    unregister(providerName: string): void;
+    getProvider(name: string): IFundamentalsProvider | undefined;
+    getAllProviders(): IFundamentalsProvider[];
+    getEnabledProviders(): IFundamentalsProvider[];
+}

package/dist_ts/stocks/interfaces/fundamentals.js

@@ -0,0 +1,6 @@
+/**
+ * Interfaces for stock fundamental data (financials from SEC filings)
+ * Separate from stock price data (OHLCV) to maintain clean architecture
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuZGFtZW50YWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvc3RvY2tzL2ludGVyZmFjZXMvZnVuZGFtZW50YWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRyJ9