ERROR  ReferenceError: Property 'processContent' doesn't exist
This error is located at:
    in RSSReadScreen (created by SceneView) böyle bi hata alıyoruz:

import React, { useEffect, useState, useRef, useCallback, useMemo } from 'react';
import { 
  View, 
  StyleSheet, 
  Text, 
  ActivityIndicator, 
  BackHandler, 
  Alert, 
  TouchableOpacity,
  Dimensions,
  I18nManager
} from 'react-native';
import { Ionicons } from '@expo/vector-icons';
import WordExplanationBox from './WordExplanationBox';
import AsyncStorage from '@react-native-async-storage/async-storage';
import * as Font from 'expo-font';
import { useThemeAndLanguage } from '../utils/ThemeAndLanguageContext';
import { 
  BottomSheetModal, 
  BottomSheetModalProvider,
} from '@gorhom/bottom-sheet';
import { useFocusEffect } from '@react-navigation/native';
import { useVocabulary } from './VocabularyContext';
import ToggleHeartButton from './heart';
import DiacriticsToggleButton from '../components/DiacriticsToggleButton';
import { removeDiacritics } from '../utils/arabicUtils';
import { WebView } from 'react-native-webview';
import Tooltip from 'react-native-walkthrough-tooltip';

const SCREEN_WIDTH = Dimensions.get('window').width;

const ARABIC_FONTS = {
  'Mirza': require('../../assets/fonts/mirza.ttf'),
  'NotoSansArabic': require('../../assets/fonts/NotoSansArabic-Regular.ttf'),
  'Amiri': require('../../assets/fonts/amiri.ttf'),
  'NotoNaskhArabic': require('../../assets/fonts/noto.ttf'),
};

const STORAGE_KEY = '@user_words';

const RSSReadScreen = ({ route, navigation }) => {
  const { item } = route.params; // RSS item
  const [fontSize, setFontSize] = useState(20);
  const [selectedContent, setSelectedContent] = useState(null); // Hem kelime hem de cümle
  const [explanationType, setExplanationType] = useState('word'); // 'word' veya 'sentence'
  const [loading, setLoading] = useState(true);
  const bottomSheetModalRef = useRef(null);
  const { locale, theme, arabicFont, arabicFontBold, setFontFamily, t } = useThemeAndLanguage();
  const [activeModal, setActiveModal] = useState(null);
  const [knownWords, setKnownWords] = useState(new Set());
  const { vocabulary, isLoggedIn, userId } = useVocabulary();
  const [diacriticsState, setDiacriticsState] = useState('normal'); // 'normal', 'red', 'hidden'
  const settingsBottomSheetModalRef = useRef(null);

 const [tooltipVisible, setTooltipVisible] = useState(false);
  const [tooltipContent, setTooltipContent] = useState('');
  const [tooltipPosition, setTooltipPosition] = useState({ x: 0, y: 0 });
  const [selectionInProgress, setSelectionInProgress] = useState(false);
  

  // State for Sentence Range
  const [selectedSentenceRange, setSelectedSentenceRange] = useState({ start: 0, end: 0 });

  // Fonları yüklüyoruz
  const loadFonts = useCallback(async () => {
    await Font.loadAsync(ARABIC_FONTS);
  }, []);

  // Kullanıcının bilinen kelimelerini yüklüyoruz
  const fetchKnownWords = useCallback(async () => {
    if (!isLoggedIn) {
      setKnownWords(new Set());
      return;
    }

    try {
      const cachedWords = await AsyncStorage.getItem(STORAGE_KEY);
      if (cachedWords) {
        const wordsArray = JSON.parse(cachedWords);
        setKnownWords(new Set(wordsArray.map(word => word.word)));
      }
    } catch (error) {
      console.error('Error fetching known words:', error);
    }
  }, [isLoggedIn]);

  useEffect(() => {
    const initialize = async () => {
      await loadFonts();
      await fetchKnownWords();
      setLoading(false);
    };

    initialize();
  }, [loadFonts, fetchKnownWords]);

  // Header ayarlarını yapıyoruz
  useEffect(() => {
    if (item) {
      navigation.setOptions({
        headerTitle: () => (
          <View style={styles.headerTitleContainer}>
            <Text 
              style={{ 
                color: theme.textColor, 
                fontWeight: 'bold', 
                fontSize: 17, 
                maxWidth: '85%', 
                textAlign: 'center',
              }} 
              numberOfLines={2} 
              ellipsizeMode="tail"
            >
              {item.title}
            </Text>
          </View>
        ),
        headerStyle: { backgroundColor: theme.lighterCardBackgroundColor },
        headerTintColor: theme.textColor,
        headerRight: () => (
          <View style={styles.headerRight}>
            <ToggleHeartButton storyId={item.id} initialHeartCount={item.hearts} />
            <DiacriticsToggleButton
              diacriticsState={diacriticsState}
              onToggle={toggleDiacritics}
              color={theme.textColor}
            />
            <Ionicons name="text" size={24} color={theme.textColor} style={styles.fontSizeControl} onPress={openSettingsModal} />
          </View>
        ),
      });
    }
  }, [navigation, item, theme, diacriticsState, toggleDiacritics, openSettingsModal]);

  useFocusEffect(
    useCallback(() => {
      const onBackPress = () => {
        if (activeModal) {
          bottomSheetModalRef.current?.dismiss();
          settingsBottomSheetModalRef.current?.dismiss();
          setActiveModal(null);
          return true;
        }
        return false;
      };

      BackHandler.addEventListener('hardwareBackPress', onBackPress);

      return () => BackHandler.removeEventListener('hardwareBackPress', onBackPress);
    }, [activeModal])
  );

  const toggleDiacritics = useCallback(() => {
    setDiacriticsState(prevState => {
      if (prevState === 'normal') return 'red';
      if (prevState === 'red') return 'hidden';
      return 'normal';
    });
  }, []);

  const openSettingsModal = useCallback(() => {
    settingsBottomSheetModalRef.current?.present();
    setActiveModal('settings');
  }, []);

  const closeAllModals = useCallback(() => {
    bottomSheetModalRef.current?.dismiss();
    settingsBottomSheetModalRef.current?.dismiss();
    setActiveModal(null);
  }, []);

  // Function to get the full sentence based on selection
  const getFullSentence = (text, partialSelection) => {
    // Noktalama işaretlerini kullanarak cümle sınırlarını bul
    const sentenceBreaks = ['.', '!', '?', '۔', '؟', '।'];
    let startIndex = text.lastIndexOfAny(sentenceBreaks, partialSelection.start);
    startIndex = startIndex === -1 ? 0 : startIndex + 1;
    
    let endIndex = text.indexOfAny(sentenceBreaks, partialSelection.end);
    endIndex = endIndex === -1 ? text.length : endIndex + 1;
    
    return {
      text: text.substring(startIndex, endIndex).trim(),
      range: { start: startIndex, end: endIndex }
    };
  };

  // Helper function to mimic lastIndexOfAny and indexOfAny
  // Since JavaScript doesn't have these functions natively
  String.prototype.lastIndexOfAny = function(chars, fromIndex) {
    let last = -1;
    for (let char of chars) {
      const index = this.lastIndexOf(char, fromIndex);
      if (index > last) {
        last = index;
      }
    }
    return last;
  };

  String.prototype.indexOfAny = function(chars, fromIndex) {
    let first = this.length;
    for (let char of chars) {
      const index = this.indexOf(char, fromIndex);
      if (index !== -1 && index < first) {
        first = index;
      }
    }
    return first === this.length ? -1 : first;
  };

  // handleWebViewMessage fonksiyonunu ekliyoruz
  const handleWebViewMessage = useCallback((event) => {
    try {
      const { type, content, selection, x, y, action } = JSON.parse(event.nativeEvent.data);
      
      if (type === 'wordTap') {
        setSelectedContent(content);
        setExplanationType('word');
        bottomSheetModalRef.current?.present();
        setActiveModal('word');
      } else if (type === 'selectionStart') {
        setSelectionInProgress(true);
        setTooltipVisible(false);
      } else if (type === 'selectionEnd') {
        const fullText = item.content || item.description || '';
        const plainText = fullText.replace(/<[^>]+>/g, '');
        
        const { text } = getFullSentence(plainText, selection);
        setSelectedContent(text);
        setTooltipContent(text);
        setTooltipPosition({ x, y });
        setSelectionInProgress(false);
        setTooltipVisible(true);
      }
    } catch (error) {
      console.error('WebView mesaj işleme hatası:', error);
    }
  }, [item]);

  const handleCopy = () => {
    //Clipboard.setString(tooltipContent);
    Alert.alert("Başarılı", "Cümle kopyalandı.");
    setTooltipVisible(false);
  };

  const handleTranslate = () => {
    setSelectedContent(tooltipContent);
    setExplanationType('sentence');
    bottomSheetModalRef.current?.present();
    setActiveModal('sentence');
    setTooltipVisible(false);
  };

  const formattedContent = useMemo(() => {
    const content = item.content || item.description || '';
    const plainText = content.replace(/<[^>]+>/g, '');
    
    const html = `
      <html dir="rtl">
        <head>
          <meta charset="utf-8">
          <meta name="viewport" content="width=device-width, initial-scale=1.0">
          <style>
            body { 
              font-size: ${fontSize}px; 
              color: ${theme.textColor}; 
              background-color: ${theme.backgroundColorForWordBox};
              font-family: '${arabicFont}';
              padding: 16px;
              line-height: 1.8;
              user-select: text;
              -webkit-user-select: text;
              direction: rtl;
              text-align: right;
            }
            .known-word {
              background-color: rgba(0, 255, 0, 0.1);
              border-radius: 5px;
              padding: 2px 4px;
            }
            .red-diacritics {
              color: red;
            }
            .selected-text {
              background-color: rgba(66, 135, 245, 0.2);
              border-radius: 3px;
            }
            .word {
              cursor: pointer;
              padding: 2px 4px;
              border-radius: 3px;
              transition: background-color 0.2s;
            }
            .word:active {
              background-color: rgba(66, 135, 245, 0.1);
            }
          </style>
        </head>
        <body>
          ${processContent(plainText, knownWords, diacriticsState)}
          <script>
            (function() {
              let selection = '';
              let isSelecting = false;
              let startX, startY;

              document.addEventListener('selectionchange', function() {
                if (isSelecting) {
                  selection = window.getSelection().toString();
                }
              });

              document.addEventListener('touchstart', function(e) {
                isSelecting = true;
                startX = e.touches[0].clientX;
                startY = e.touches[0].clientY;
                window.ReactNativeWebView.postMessage(JSON.stringify({
                  type: 'selectionStart'
                }));
              });

              document.addEventListener('touchend', function(e) {
                if (isSelecting && selection) {
                  const selectionRange = window.getSelection().getRangeAt(0);
                  const rect = selectionRange.getBoundingClientRect();
                  
                  window.ReactNativeWebView.postMessage(JSON.stringify({
                    type: 'selectionEnd',
                    content: selection,
                    selection: {
                      start: selectionRange.startOffset,
                      end: selectionRange.endOffset
                    },
                    x: rect.left + (rect.width / 2),
                    y: rect.top
                  }));
                }
                isSelecting = false;
              });

              document.querySelectorAll('.word').forEach(function(element) {
                element.addEventListener('click', function(e) {
                  if (!selection) {
                    const word = this.innerText;
                    window.ReactNativeWebView.postMessage(JSON.stringify({ 
                      type: 'wordTap', 
                      content: word 
                    }));
                  }
                });
              });
            })();
          </script>
        </body>
      </html>
    `;
    return html;
  }, [item.content, item.description, fontSize, theme, arabicFont, knownWords, diacriticsState, processContent]);

  return (
    <BottomSheetModalProvider>
      <View style={[styles.container, { backgroundColor: theme.backgroundColorForWordBox }]}>
        <WebView
          originWhitelist={['*']}
          source={{ html: formattedContent }}
          onMessage={handleWebViewMessage}
          javaScriptEnabled={true}
          domStorageEnabled={true}
          scalesPageToFit={false}
          style={{ flex: 1 }}
        />

        <Tooltip
          isVisible={tooltipVisible}
          content={
            <View style={styles.tooltipContainer}>
              <Text style={styles.selectedText} numberOfLines={2}>
                {tooltipContent}
              </Text>
              <View style={styles.tooltipActions}>
                <TouchableOpacity 
                  style={styles.tooltipButton} 
                  onPress={handleCopy}
                >
                  <Ionicons name="copy-outline" size={20} color={theme.primaryColor} />
                  <Text style={styles.tooltipButtonText}>{t('copy')}</Text>
                </TouchableOpacity>
                <View style={styles.buttonDivider} />
                <TouchableOpacity 
                  style={styles.tooltipButton} 
                  onPress={handleTranslate}
                >
                  <Ionicons name="language-outline" size={20} color={theme.primaryColor} />
                  <Text style={styles.tooltipButtonText}>{t('translate')}</Text>
                </TouchableOpacity>
              </View>
            </View>
          }
          placement="top"
          onClose={() => setTooltipVisible(false)}
          contentStyle={styles.tooltip}
          tooltipStyle={styles.tooltipStyle}
          backgroundColor="transparent"
          topAdjustment={Platform.OS === 'android' ? -StatusBar.currentHeight : 0}
        />

        {/* ... (rest of the components remain the same) */}
      </View>
    </BottomSheetModalProvider>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
  },
  loadingContainer: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
  },
  headerTitleContainer: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
  },
  headerRight: {
    flexDirection: 'row',
    alignItems: 'center',
  },
  fontSizeControl: {
    marginLeft: 10,
  },
  settingsContent: {
    flex: 1,
    padding: 20,
  },
  fontSizeControls: {
    flexDirection: 'row',
    justifyContent: 'space-around',
    marginVertical: 20,
  },
  fontOptionsContainer: {
    flexDirection: 'row',
    flexWrap: 'wrap',
    justifyContent: 'space-around',
  },
  fontOption: {
    width: '45%',
    backgroundColor: '#fff',
    borderRadius: 10,
    padding: 10,
    marginBottom: 20,
    alignItems: 'center',
    elevation: 4,
    shadowColor: '#000',
    shadowOffset: { width: 0, height: 1 },
    shadowOpacity: 0.22,
    shadowRadius: 2.22,
  },
  fontOptionText: {
    fontSize: 16,
    marginBottom: 5,
    textAlign: 'center',
    color: '#000',
  },
  fontOptionSample: {
    fontSize: 18,
  },
  popover: {
    backgroundColor: 'white',
    borderRadius: 8,
    padding: 0,
    shadowColor: "#000",
    shadowOffset: {
      width: 0,
      height: 2,
    },
    shadowOpacity: 0.25,
    shadowRadius: 3.84,
    elevation: 5,
  },
  popoverContainer: {
    width: SCREEN_WIDTH * 0.8,
    maxWidth: 400,
    padding: 12,
  },
  selectedText: {
    fontSize: 14,
    color: '#666',
    marginBottom: 12,
    lineHeight: 20,
  },
tooltip: {
    backgroundColor: 'white',
    borderRadius: 8,
    padding: 0,
  },
  tooltipStyle: {
    padding: 0,
  },
  tooltipContainer: {
    width: SCREEN_WIDTH * 0.8,
    maxWidth: 400,
    padding: 12,
  },
  selectedText: {
    fontSize: 14,
    color: '#666',
    marginBottom: 12,
    lineHeight: 20,
    textAlign: 'right',
  },
  tooltipActions: {
    flexDirection: 'row',
    borderTopWidth: 1,
    borderTopColor: '#eee',
    paddingTop: 12,
    justifyContent: 'space-around',
  },
  tooltipButton: {
    flexDirection: 'row',
    alignItems: 'center',
    paddingVertical: 8,
    paddingHorizontal: 16,
  },
  tooltipButtonText: {
    marginLeft: 8,
    fontSize: 14,
    color: '#333',
  },
  buttonDivider: {
    width: 1,
    backgroundColor: '#eee',
  },
});

export default RSSReadScreen;