react-native-pdf-jsi 1.0.1

package/android/src/main/java/org/wonday/pdf/PDFJSIManager.java

@@ -0,0 +1,317 @@
+/**
+ * Copyright (c) 2025-present, Punith M (punithm300@gmail.com)
+ * Enhanced PDF JSI Manager with high-performance operations
+ * All rights reserved.
+ * 
+ * JSI Manager for high-performance PDF operations
+ * Provides React Native bridge integration for JSI PDF functions
+ */
+
+package org.wonday.pdf;
+
+import android.util.Log;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.Arguments;
+
+// import com.facebook.react.turbomodule.core.CallInvokerHolder; // Not available in this RN version
+import com.facebook.soloader.SoLoader;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class PDFJSIManager extends ReactContextBaseJavaModule {
+    private static final String MODULE_NAME = "PDFJSIManager";
+    private static final String TAG = "PDFJSI";
+    
+    private ExecutorService backgroundExecutor;
+    private boolean isJSIInitialized = false;
+    
+    // Load native library
+    static {
+        try {
+            SoLoader.loadLibrary("pdfjsi");
+            Log.d(TAG, "PDF JSI native library loaded successfully");
+        } catch (UnsatisfiedLinkError e) {
+            Log.e(TAG, "Failed to load PDF JSI native library", e);
+        }
+    }
+    
+    public PDFJSIManager(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.backgroundExecutor = Executors.newFixedThreadPool(2);
+        
+        Log.d(TAG, "PDFJSIManager: Initializing high-performance PDF JSI manager");
+        initializeJSI(reactContext);
+    }
+    
+    @Override
+    public String getName() {
+        return MODULE_NAME;
+    }
+    
+    /**
+     * Initialize JSI integration
+     */
+    private void initializeJSI(ReactApplicationContext reactContext) {
+        try {
+            // Initialize JSI on background thread
+            backgroundExecutor.execute(() -> {
+                try {
+                    // Initialize JSI module without CallInvokerHolder (fallback mode)
+                    nativeInitializeJSI(null);
+                    isJSIInitialized = true;
+                    Log.d(TAG, "PDF JSI initialized successfully (fallback mode)");
+                } catch (Exception e) {
+                    Log.e(TAG, "Failed to initialize PDF JSI", e);
+                }
+            });
+        } catch (Exception e) {
+            Log.e(TAG, "Error initializing PDF JSI", e);
+        }
+    }
+    
+    /**
+     * Check if JSI is available and initialized
+     */
+    @ReactMethod
+    public void isJSIAvailable(Promise promise) {
+        try {
+            boolean available = isJSIInitialized && nativeIsJSIAvailable();
+            Log.d(TAG, "JSI Availability check: " + available);
+            promise.resolve(available);
+        } catch (Exception e) {
+            Log.e(TAG, "Error checking JSI availability", e);
+            promise.reject("JSI_CHECK_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Render page directly via JSI (high-performance)
+     */
+    @ReactMethod
+    public void renderPageDirect(String pdfId, int pageNumber, double scale, String base64Data, Promise promise) {
+        if (!isJSIInitialized) {
+            promise.reject("JSI_NOT_INITIALIZED", "JSI is not initialized");
+            return;
+        }
+        
+        backgroundExecutor.execute(() -> {
+            try {
+                Log.d(TAG, "Rendering page " + pageNumber + " via JSI for PDF " + pdfId);
+                WritableMap result = nativeRenderPageDirect(pdfId, pageNumber, (float) scale, base64Data);
+                promise.resolve(result);
+            } catch (Exception e) {
+                Log.e(TAG, "Error rendering page via JSI", e);
+                promise.reject("RENDER_ERROR", e.getMessage());
+            }
+        });
+    }
+    
+    /**
+     * Get page metrics via JSI
+     */
+    @ReactMethod
+    public void getPageMetrics(String pdfId, int pageNumber, Promise promise) {
+        if (!isJSIInitialized) {
+            promise.reject("JSI_NOT_INITIALIZED", "JSI is not initialized");
+            return;
+        }
+        
+        try {
+            Log.d(TAG, "Getting page metrics via JSI for page " + pageNumber);
+            WritableMap metrics = nativeGetPageMetrics(pdfId, pageNumber);
+            promise.resolve(metrics);
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting page metrics via JSI", e);
+            promise.reject("METRICS_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Preload pages directly via JSI
+     */
+    @ReactMethod
+    public void preloadPagesDirect(String pdfId, int startPage, int endPage, Promise promise) {
+        if (!isJSIInitialized) {
+            promise.reject("JSI_NOT_INITIALIZED", "JSI is not initialized");
+            return;
+        }
+        
+        backgroundExecutor.execute(() -> {
+            try {
+                Log.d(TAG, "Preloading pages " + startPage + "-" + endPage + " via JSI");
+                boolean success = nativePreloadPagesDirect(pdfId, startPage, endPage);
+                promise.resolve(success);
+            } catch (Exception e) {
+                Log.e(TAG, "Error preloading pages via JSI", e);
+                promise.reject("PRELOAD_ERROR", e.getMessage());
+            }
+        });
+    }
+    
+    /**
+     * Get cache metrics via JSI
+     */
+    @ReactMethod
+    public void getCacheMetrics(String pdfId, Promise promise) {
+        if (!isJSIInitialized) {
+            promise.reject("JSI_NOT_INITIALIZED", "JSI is not initialized");
+            return;
+        }
+        
+        try {
+            Log.d(TAG, "Getting cache metrics via JSI for PDF " + pdfId);
+            WritableMap metrics = nativeGetCacheMetrics(pdfId);
+            promise.resolve(metrics);
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting cache metrics via JSI", e);
+            promise.reject("CACHE_METRICS_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Clear cache directly via JSI
+     */
+    @ReactMethod
+    public void clearCacheDirect(String pdfId, String cacheType, Promise promise) {
+        if (!isJSIInitialized) {
+            promise.reject("JSI_NOT_INITIALIZED", "JSI is not initialized");
+            return;
+        }
+        
+        backgroundExecutor.execute(() -> {
+            try {
+                Log.d(TAG, "Clearing cache via JSI for PDF " + pdfId + ", type: " + cacheType);
+                boolean success = nativeClearCacheDirect(pdfId, cacheType);
+                promise.resolve(success);
+            } catch (Exception e) {
+                Log.e(TAG, "Error clearing cache via JSI", e);
+                promise.reject("CLEAR_CACHE_ERROR", e.getMessage());
+            }
+        });
+    }
+    
+    /**
+     * Optimize memory via JSI
+     */
+    @ReactMethod
+    public void optimizeMemory(String pdfId, Promise promise) {
+        if (!isJSIInitialized) {
+            promise.reject("JSI_NOT_INITIALIZED", "JSI is not initialized");
+            return;
+        }
+        
+        backgroundExecutor.execute(() -> {
+            try {
+                Log.d(TAG, "Optimizing memory via JSI for PDF " + pdfId);
+                boolean success = nativeOptimizeMemory(pdfId);
+                promise.resolve(success);
+            } catch (Exception e) {
+                Log.e(TAG, "Error optimizing memory via JSI", e);
+                promise.reject("OPTIMIZE_MEMORY_ERROR", e.getMessage());
+            }
+        });
+    }
+    
+    /**
+     * Search text directly via JSI
+     */
+    @ReactMethod
+    public void searchTextDirect(String pdfId, String searchTerm, int startPage, int endPage, Promise promise) {
+        if (!isJSIInitialized) {
+            promise.reject("JSI_NOT_INITIALIZED", "JSI is not initialized");
+            return;
+        }
+        
+        backgroundExecutor.execute(() -> {
+            try {
+                Log.d(TAG, "Searching text via JSI: '" + searchTerm + "' in pages " + startPage + "-" + endPage);
+                ReadableArray results = nativeSearchTextDirect(pdfId, searchTerm, startPage, endPage);
+                promise.resolve(results);
+            } catch (Exception e) {
+                Log.e(TAG, "Error searching text via JSI", e);
+                promise.reject("SEARCH_ERROR", e.getMessage());
+            }
+        });
+    }
+    
+    /**
+     * Get performance metrics via JSI
+     */
+    @ReactMethod
+    public void getPerformanceMetrics(String pdfId, Promise promise) {
+        if (!isJSIInitialized) {
+            promise.reject("JSI_NOT_INITIALIZED", "JSI is not initialized");
+            return;
+        }
+        
+        try {
+            Log.d(TAG, "Getting performance metrics via JSI for PDF " + pdfId);
+            WritableMap metrics = nativeGetPerformanceMetrics(pdfId);
+            promise.resolve(metrics);
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting performance metrics via JSI", e);
+            promise.reject("PERFORMANCE_METRICS_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Set render quality via JSI
+     */
+    @ReactMethod
+    public void setRenderQuality(String pdfId, int quality, Promise promise) {
+        if (!isJSIInitialized) {
+            promise.reject("JSI_NOT_INITIALIZED", "JSI is not initialized");
+            return;
+        }
+        
+        try {
+            Log.d(TAG, "Setting render quality via JSI to " + quality + " for PDF " + pdfId);
+            boolean success = nativeSetRenderQuality(pdfId, quality);
+            promise.resolve(success);
+        } catch (Exception e) {
+            Log.e(TAG, "Error setting render quality via JSI", e);
+            promise.reject("SET_RENDER_QUALITY_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Cleanup resources
+     */
+    // Note: onCatalystInstanceDestroy is deprecated, using onCatalystInstanceDestroy for compatibility
+    @Override
+    public void onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy();
+        
+        if (backgroundExecutor != null && !backgroundExecutor.isShutdown()) {
+            backgroundExecutor.shutdown();
+        }
+        
+        if (isJSIInitialized) {
+            nativeCleanupJSI();
+        }
+        
+        Log.d(TAG, "PDFJSIManager: Cleaned up resources");
+    }
+    
+    // Native method declarations
+    private native void nativeInitializeJSI(Object callInvokerHolder);
+    private native boolean nativeIsJSIAvailable();
+    private native WritableMap nativeRenderPageDirect(String pdfId, int pageNumber, float scale, String base64Data);
+    private native WritableMap nativeGetPageMetrics(String pdfId, int pageNumber);
+    private native boolean nativePreloadPagesDirect(String pdfId, int startPage, int endPage);
+    private native WritableMap nativeGetCacheMetrics(String pdfId);
+    private native boolean nativeClearCacheDirect(String pdfId, String cacheType);
+    private native boolean nativeOptimizeMemory(String pdfId);
+    private native ReadableArray nativeSearchTextDirect(String pdfId, String searchTerm, int startPage, int endPage);
+    private native WritableMap nativeGetPerformanceMetrics(String pdfId);
+    private native boolean nativeSetRenderQuality(String pdfId, int quality);
+    private native void nativeCleanupJSI();
+}

package/android/src/main/java/org/wonday/pdf/PDFJSIModule.java

@@ -0,0 +1,189 @@
+/**
+ * Copyright (c) 2025-present, Punith M (punithm300@gmail.com)
+ * Enhanced PDF JSI Module with high-performance operations
+ * All rights reserved.
+ * 
+ * React Native module for JSI PDF operations
+ * Provides high-performance PDF operations via JSI
+ */
+
+package org.wonday.pdf;
+
+import android.util.Log;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.Arguments;
+
+// import com.facebook.react.turbomodule.core.CallInvokerHolder; // Not available in this RN version
+import com.facebook.soloader.SoLoader;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class PDFJSIModule extends ReactContextBaseJavaModule {
+    private static final String MODULE_NAME = "PDFJSIModule";
+    private static final String TAG = "PDFJSIModule";
+    
+    private ExecutorService backgroundExecutor;
+    private boolean isJSIInitialized = false;
+    
+    // Load native library
+    static {
+        try {
+            SoLoader.loadLibrary("pdfjsi");
+            Log.d(TAG, "PDF JSI native library loaded successfully");
+        } catch (UnsatisfiedLinkError e) {
+            Log.e(TAG, "Failed to load PDF JSI native library", e);
+        }
+    }
+    
+    public PDFJSIModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.backgroundExecutor = Executors.newFixedThreadPool(2);
+        
+        Log.d(TAG, "PDFJSIModule: Initializing high-performance PDF JSI module");
+        initializeJSI(reactContext);
+    }
+    
+    @Override
+    public String getName() {
+        return MODULE_NAME;
+    }
+    
+    /**
+     * Initialize JSI integration
+     */
+    private void initializeJSI(ReactApplicationContext reactContext) {
+        try {
+            // Initialize JSI on background thread
+            backgroundExecutor.execute(() -> {
+                try {
+                    // Initialize JSI module without CallInvokerHolder (fallback mode)
+                    nativeInitializeJSI(null);
+                    isJSIInitialized = true;
+                    Log.d(TAG, "PDF JSI initialized successfully (fallback mode)");
+                } catch (Exception e) {
+                    Log.e(TAG, "Failed to initialize PDF JSI", e);
+                }
+            });
+        } catch (Exception e) {
+            Log.e(TAG, "Error initializing PDF JSI", e);
+        }
+    }
+    
+    /**
+     * Check if JSI is available and initialized
+     */
+    @ReactMethod
+    public void isJSIAvailable(Promise promise) {
+        try {
+            boolean available = isJSIInitialized && nativeIsJSIAvailable();
+            Log.d(TAG, "JSI Availability check: " + available);
+            promise.resolve(available);
+        } catch (Exception e) {
+            Log.e(TAG, "Error checking JSI availability", e);
+            promise.reject("JSI_CHECK_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Get JSI performance statistics
+     */
+    @ReactMethod
+    public void getJSIStats(Promise promise) {
+        try {
+            Log.d(TAG, "Getting JSI stats");
+            
+            WritableMap stats = Arguments.createMap();
+            stats.putString("version", "1.0.0");
+            stats.putString("buildDate", "2025-01-01");
+            stats.putBoolean("jsiEnabled", true);
+            stats.putBoolean("bridgeOptimized", true);
+            stats.putBoolean("directMemoryAccess", true);
+            stats.putInt("availableMethods", 9);
+            stats.putString("performanceLevel", "HIGH");
+            stats.putBoolean("isInitialized", isJSIInitialized);
+            
+            promise.resolve(stats);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting JSI stats", e);
+            promise.reject("GET_JSI_STATS_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Initialize JSI with custom configuration
+     */
+    @ReactMethod
+    public void initializeJSIConfig(ReadableMap config, Promise promise) {
+        try {
+            Log.d(TAG, "Initializing JSI with custom configuration");
+            
+            boolean enablePerformanceTracking = config.getBoolean("enablePerformanceTracking");
+            boolean enableCaching = config.getBoolean("enableCaching");
+            int maxCacheSize = config.getInt("maxCacheSize");
+            
+            boolean success = nativeInitializeJSIConfig(enablePerformanceTracking, enableCaching, maxCacheSize);
+            
+            WritableMap result = Arguments.createMap();
+            result.putBoolean("success", success);
+            result.putBoolean("jsiEnabled", success);
+            result.putString("message", success ? "JSI configured successfully" : "Failed to configure JSI");
+            
+            promise.resolve(result);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error initializing JSI config", e);
+            promise.reject("JSI_CONFIG_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Get memory usage statistics
+     */
+    @ReactMethod
+    public void getMemoryStats(Promise promise) {
+        try {
+            Log.d(TAG, "Getting memory statistics");
+            
+            WritableMap stats = nativeGetMemoryStats();
+            promise.resolve(stats);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting memory stats", e);
+            promise.reject("MEMORY_STATS_ERROR", e.getMessage());
+        }
+    }
+    
+    /**
+     * Cleanup resources
+     */
+    // Note: onCatalystInstanceDestroy is deprecated, using onCatalystInstanceDestroy for compatibility
+    @Override
+    public void onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy();
+        
+        if (backgroundExecutor != null && !backgroundExecutor.isShutdown()) {
+            backgroundExecutor.shutdown();
+        }
+        
+        if (isJSIInitialized) {
+            nativeCleanupJSI();
+        }
+        
+        Log.d(TAG, "PDFJSIModule: Cleaned up resources");
+    }
+    
+    // Native method declarations
+    private native void nativeInitializeJSI(Object callInvokerHolder);
+    private native boolean nativeIsJSIAvailable();
+    private native boolean nativeInitializeJSIConfig(boolean enablePerformanceTracking, boolean enableCaching, int maxCacheSize);
+    private native WritableMap nativeGetMemoryStats();
+    private native void nativeCleanupJSI();
+}

package/android/src/main/java/org/wonday/pdf/PdfManager.java

@@ -0,0 +1,180 @@
+/**
+ * Copyright (c) 2017-present, Wonday (@wonday.org)
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package org.wonday.pdf;
+
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+import com.facebook.react.uimanager.ViewManagerDelegate;
+import com.facebook.react.viewmanagers.RNPDFPdfViewManagerDelegate;
+import com.facebook.react.viewmanagers.RNPDFPdfViewManagerInterface;
+
+@ReactModule(name = PdfManager.REACT_CLASS)
+public class PdfManager extends SimpleViewManager<PdfView> implements RNPDFPdfViewManagerInterface<PdfView> {
+    public static final String REACT_CLASS = "RNPDFPdfView";
+    private Context context;
+    private PdfView pdfView;
+    private final ViewManagerDelegate<PdfView> mDelegate;
+
+    @Nullable
+    @Override
+    protected ViewManagerDelegate<PdfView> getDelegate() {
+        return mDelegate;
+    }
+
+    public PdfManager() {
+        mDelegate = new RNPDFPdfViewManagerDelegate<>(this);
+    }
+
+    public PdfManager(ReactApplicationContext reactContext){
+        this.context = reactContext;
+        mDelegate = new RNPDFPdfViewManagerDelegate<>(this);
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    public PdfView createViewInstance(ThemedReactContext context) {
+        this.pdfView = new PdfView(context,null);
+        return pdfView;
+    }
+
+    @Override
+    public void onDropViewInstance(PdfView pdfView) {
+        pdfView = null;
+    }
+
+    @ReactProp(name = "path")
+    public void setPath(PdfView pdfView, String path) {
+        pdfView.setPath(path);
+    }
+
+    // page start from 1
+    @ReactProp(name = "page")
+    public void setPage(PdfView pdfView, int page) {
+        pdfView.setPage(page);
+    }
+
+    @ReactProp(name = "scale")
+    public void setScale(PdfView pdfView, float scale) {
+        pdfView.setScale(scale);
+    }
+
+    @ReactProp(name = "minScale")
+    public void setMinScale(PdfView pdfView, float minScale) {
+        pdfView.setMinScale(minScale);
+    }
+
+    @ReactProp(name = "maxScale")
+    public void setMaxScale(PdfView pdfView, float maxScale) {
+        pdfView.setMaxScale(maxScale);
+    }
+
+    @ReactProp(name = "horizontal")
+    public void setHorizontal(PdfView pdfView, boolean horizontal) {
+        pdfView.setHorizontal(horizontal);
+    }
+
+    @Override
+    public void setShowsHorizontalScrollIndicator(PdfView view, boolean value) {
+        // NOOP on Android
+    }
+
+    @Override
+    public void setShowsVerticalScrollIndicator(PdfView view, boolean value) {
+        // NOOP on Android
+    }
+
+    @ReactProp(name = "scrollEnabled")
+    public void setScrollEnabled(PdfView view, boolean scrollEnabled) {
+        pdfView.setScrollEnabled(scrollEnabled);
+    }
+
+    @ReactProp(name = "spacing")
+    public void setSpacing(PdfView pdfView, int spacing) {
+        pdfView.setSpacing(spacing);
+    }
+
+    @ReactProp(name = "password")
+    public void setPassword(PdfView pdfView, String password) {
+        pdfView.setPassword(password);
+    }
+
+    @ReactProp(name = "enableAntialiasing")
+    public void setEnableAntialiasing(PdfView pdfView, boolean enableAntialiasing) {
+        pdfView.setEnableAntialiasing(enableAntialiasing);
+    }
+
+    @ReactProp(name = "enableAnnotationRendering")
+    public void setEnableAnnotationRendering(PdfView pdfView, boolean enableAnnotationRendering) {
+        pdfView.setEnableAnnotationRendering(enableAnnotationRendering);
+    }
+
+    @ReactProp(name = "enableDoubleTapZoom")
+    public void setEnableDoubleTapZoom(PdfView pdfView, boolean enableDoubleTap) {
+        pdfView.setEnableDoubleTapZoom(enableDoubleTap);
+    }
+
+    @ReactProp(name = "enablePaging")
+    public void setEnablePaging(PdfView pdfView, boolean enablePaging) {
+        pdfView.setEnablePaging(enablePaging);
+    }
+
+    @Override
+    public void setEnableRTL(PdfView view, boolean value) {
+        // NOOP on Android
+    }
+
+    @ReactProp(name = "fitPolicy")
+    public void setFitPolicy(PdfView pdfView, int fitPolicy) {
+        pdfView.setFitPolicy(fitPolicy);
+    }
+
+    @ReactProp(name = "singlePage")
+    public void setSinglePage(PdfView pdfView, boolean singlePage) {
+        pdfView.setSinglePage(singlePage);
+    }
+
+    // It seems funny, but this method is called through delegate on Paper, but on Fabric we need to
+    // use `receiveCommand` method and call this one there
+    @Override
+    public void setNativePage(PdfView view, int page) {
+        pdfView.setPage(page);
+    }
+
+    @Override
+    public void receiveCommand(@NonNull PdfView root, String commandId, @androidx.annotation.Nullable ReadableArray args) {
+        Assertions.assertNotNull(root);
+        if ("setNativePage".equals(commandId)) {
+            Assertions.assertNotNull(args);
+            assert args != null;
+            setNativePage(root, args.getInt(0));
+        }
+    }
+
+    @Override
+    public void onAfterUpdateTransaction(PdfView pdfView) {
+        super.onAfterUpdateTransaction(pdfView);
+        pdfView.drawPdf();
+    }
+
+}