diff --git a/PdfiumAndroid/arrow/build.gradle.kts b/PdfiumAndroid/arrow/build.gradle.kts
index 9514dce..45ab5df 100644
--- a/PdfiumAndroid/arrow/build.gradle.kts
+++ b/PdfiumAndroid/arrow/build.gradle.kts
@@ -1,6 +1,10 @@
+
+
+
 plugins {
     alias(libs.plugins.androidLibrary)
     alias(libs.plugins.kotlinAndroid)
+    `maven-publish`
 }
 
 android {
@@ -39,4 +43,83 @@ dependencies {
     testImplementation(libs.junit)
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.espresso.core)
+    androidTestImplementation(libs.truth)
+    androidTestImplementation(libs.kotlinx.coroutines.test)
+    androidTestImplementation(libs.androidx.core.testing)
+    androidTestImplementation(libs.arrow.fx.coroutines)
+}
+
+fun isReleaseBuild(): Boolean = !findProject("VERSION_NAME").toString().contains("SNAPSHOT")
+
+fun getReleaseRepositoryUrl(): String {
+    return if (rootProject.hasProperty("RELEASE_REPOSITORY_URL")) {
+        rootProject.properties["RELEASE_REPOSITORY_URL"] as String
+    } else {
+        "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
+    }
+}
+
+fun getSnapshotRepositoryUrl(): String {
+    return if (rootProject.hasProperty("SNAPSHOT_REPOSITORY_URL")) {
+        rootProject.properties["SNAPSHOT_REPOSITORY_URL"] as String
+    } else {
+        "https://oss.sonatype.org/content/repositories/snapshots/"
+    }
+}
+
+fun getRepositoryUrl(): String {
+    return if (isReleaseBuild()) getReleaseRepositoryUrl() else getSnapshotRepositoryUrl()
+}
+
+fun getRepositoryUsername(): String {
+    return if (rootProject.hasProperty("NEXUS_USERNAME")) rootProject.properties["NEXUS_USERNAME"] as String else ""
+}
+
+fun getRepositoryPassword(): String {
+    return if (rootProject.hasProperty("NEXUS_PASSWORD")) rootProject.properties["NEXUS_PASSWORD"] as String else ""
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("maven") {
+            groupId = "io.legere"
+            artifactId = "pdfiumandroid-arrow"
+            version = rootProject.properties["VERSION_NAME"] as String
+
+            pom {
+                name.set("PdfiumAndroid.Arrow")
+                description.set("Arrow support for PdfiumAndroid")
+                url.set(rootProject.properties["POM_URL"] as String)
+                licenses {
+                    license {
+                        name.set(rootProject.properties["POM_LICENCE_NAME"] as String)
+                        url.set(rootProject.properties["POM_LICENCE_URL"] as String)
+                    }
+                }
+                developers {
+                    developer {
+                        id.set(rootProject.properties["POM_DEVELOPER_ID"] as String)
+                        name.set(rootProject.properties["POM_DEVELOPER_NAME"] as String)
+                    }
+                }
+                scm {
+                    connection.set(rootProject.properties["POM_SCM_CONNECTION"] as String)
+                    developerConnection.set(rootProject.properties["POM_SCM_DEV_CONNECTION"] as String)
+                    url.set(rootProject.properties["POM_SCM_URL"] as String)
+                }
+            }
+            afterEvaluate {
+                from(components["release"])
+            }
+        }
+    }
+    repositories {
+        maven {
+            url = uri(getRepositoryUrl())
+            credentials {
+                username = getRepositoryUsername()
+                password = getRepositoryPassword()
+            }
+        }
+    }
 }
diff --git a/PdfiumAndroid/arrow/gradle.properties b/PdfiumAndroid/arrow/gradle.properties
new file mode 100644
index 0000000..74498a9
--- /dev/null
+++ b/PdfiumAndroid/arrow/gradle.properties
@@ -0,0 +1,4 @@
+POM_NAME=PdfiumAndroid
+POM_ARTIFACT_ID=pdfiumandroid
+POM_PACKAGING=aar
+
diff --git a/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/BasePDFTest.kt b/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/BasePDFTest.kt
new file mode 100644
index 0000000..5f3c838
--- /dev/null
+++ b/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/BasePDFTest.kt
@@ -0,0 +1,28 @@
+package io.legere.pdfiumandroid.arrow
+
+import android.graphics.RectF
+import android.util.Log
+import androidx.test.platform.app.InstrumentationRegistry
+
+@Suppress("unused")
+open class BasePDFTest {
+
+    // set to true to skip tests that are not implemented yet
+    // set to false to force unimplemented tests to fail
+    val notImplementedAssetValue = false
+
+    val noResultRect = RectF(-1f, -1f, -1f, -1f)
+
+    fun getPdfBytes(filename: String): ByteArray? {
+        val appContext = InstrumentationRegistry.getInstrumentation().context
+        val assetManager = appContext.assets
+        try {
+            val input = assetManager.open(filename)
+            return input.readBytes()
+        } catch (e: Exception) {
+            Log.e(BasePDFTest::class.simpleName, "Ugh", e)
+        }
+        assetManager.close()
+        return null
+    }
+}
diff --git a/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/ExampleInstrumentedTest.kt b/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/ExampleInstrumentedTest.kt
deleted file mode 100644
index a4ac796..0000000
--- a/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/ExampleInstrumentedTest.kt
+++ /dev/null
@@ -1,22 +0,0 @@
-package io.legere.pdfiumandroid.arrow
-
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import org.junit.Assert.assertEquals
-import org.junit.Test
-import org.junit.runner.RunWith
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-@RunWith(AndroidJUnit4::class)
-class ExampleInstrumentedTest {
-    @Test
-    fun useAppContext() {
-        // Context of the app under test.
-        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("io.legere.pdfiumandroid.arrow.test", appContext.packageName)
-    }
-}
diff --git a/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfDocumentKtFTest.kt b/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfDocumentKtFTest.kt
new file mode 100644
index 0000000..3f16a41
--- /dev/null
+++ b/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfDocumentKtFTest.kt
@@ -0,0 +1,122 @@
+package io.legere.pdfiumandroid.arrow
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import arrow.core.raise.either
+import com.google.common.truth.Truth
+import io.legere.pdfiumandroid.PdfWriteCallback
+import junit.framework.TestCase
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class PdfDocumentKtFTest : BasePDFTest() {
+
+    private lateinit var pdfDocument: PdfDocumentKtF
+    private var pdfBytes: ByteArray? = null
+
+    @Before
+    fun setUp() = runBlocking {
+        pdfBytes = getPdfBytes("f01.pdf")
+
+        TestCase.assertNotNull(pdfBytes)
+
+        pdfDocument = PdfiumCoreKtF(Dispatchers.Unconfined).newDocument(pdfBytes).getOrNull()!!
+    }
+
+    @After
+    fun tearDown() = runTest {
+        pdfDocument.close()
+    }
+
+    @Test
+    fun getPageCount() = runTest {
+        either {
+            val pageCount = pdfDocument.getPageCount().bind()
+
+            assert(pageCount == 4) { "Page count should be 4" }
+        }
+    }
+
+    @Test
+    fun openPage() = runTest {
+        either {
+            val page = pdfDocument.openPage(0).bind()
+
+            TestCase.assertNotNull(page)
+        }
+    }
+
+    @Test
+    fun openPages() = runTest {
+        either {
+            val page = pdfDocument.openPages(0, 3).bind()
+
+            assert(page.size == 4) { "Page count should be 4" }
+        }
+    }
+
+    @Test
+    fun getDocumentMeta() = runTest {
+        either {
+            val meta = pdfDocument.getDocumentMeta().bind()
+
+            TestCase.assertNotNull(meta)
+        }
+    }
+
+    @Test
+    fun getTableOfContents() = runTest {
+        either {
+            // I don't think this test document has a table of contents
+            val toc = pdfDocument.getTableOfContents().bind()
+
+            TestCase.assertNotNull(toc)
+            Truth.assertThat(toc.size).isEqualTo(0)
+        }
+    }
+
+    @Test
+    fun openTextPage() = runTest {
+        either {
+            val page = pdfDocument.openPage(0).bind()
+            val textPage = page.openTextPage().bind()
+            TestCase.assertNotNull(textPage)
+        }
+    }
+
+    @Test
+    fun openTextPages() = runTest {
+        either {
+            val textPages = pdfDocument.openTextPages(0, 3).bind()
+            Truth.assertThat(textPages.size).isEqualTo(4)
+        }
+    }
+
+    @Test
+    fun saveAsCopy() = runTest {
+        pdfDocument.saveAsCopy(object : PdfWriteCallback {
+            override fun WriteBlock(data: ByteArray?): Int {
+                // Truth.assertThat(data?.size).isEqualTo(pdfBytes?.size)
+                // Truth.assertThat(data).isEqualTo(pdfBytes)
+                return data?.size ?: 0
+            }
+        })
+    }
+
+    fun close() = runTest {
+        either {
+            var documentAfterClose: PdfDocumentKtF?
+            PdfiumCoreKtF(Dispatchers.Unconfined).newDocument(pdfBytes).bind().use {
+                documentAfterClose = it
+            }
+            documentAfterClose?.openPage(0)
+        }.mapLeft {
+            Truth.assertThat(it).isInstanceOf(PdfiumKtFErrors.AlreadyClosed::class.java)
+        }
+    }
+}
diff --git a/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfPageKtFTest.kt b/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfPageKtFTest.kt
new file mode 100644
index 0000000..17f65a6
--- /dev/null
+++ b/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfPageKtFTest.kt
@@ -0,0 +1,290 @@
+package io.legere.pdfiumandroid.arrow
+
+import android.graphics.Bitmap
+import android.graphics.Point
+import android.graphics.PointF
+import android.graphics.Rect
+import android.graphics.RectF
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import arrow.core.raise.either
+import com.google.common.truth.Truth.assertThat
+import io.legere.pdfiumandroid.util.Size
+import junit.framework.TestCase
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class PdfPageKtFTest : BasePDFTest() {
+
+    private lateinit var pdfDocument: PdfDocumentKtF
+    private var pdfBytes: ByteArray? = null
+
+    @Before
+    fun setUp() = runBlocking {
+        pdfBytes = getPdfBytes("f01.pdf")
+
+        TestCase.assertNotNull(pdfBytes)
+
+        pdfDocument = PdfiumCoreKtF(Dispatchers.Unconfined).newDocument(pdfBytes).getOrNull()!!
+    }
+
+    @After
+    fun tearDown() {
+        pdfDocument.close()
+    }
+
+    @Test
+    fun getPageWidth() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val pageWidth = page.getPageWidth(72).bind()
+
+                assertThat(pageWidth).isEqualTo(612) // 8.5 inches * 72 dpi
+            }
+        }
+    }
+
+    @Test
+    fun getPageHeight() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val pageWidth = page.getPageHeight(72).bind()
+
+                assertThat(pageWidth).isEqualTo(792) // 11 inches * 72 dpi
+            }
+        }
+    }
+
+    @Test
+    fun getPageWidthPoint() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val pageWidth = page.getPageWidthPoint().bind()
+
+                assertThat(pageWidth).isEqualTo(612) // 11 inches * 72 dpi
+            }
+        }
+    }
+
+    @Test
+    fun getPageHeightPoint() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val pageWidth = page.getPageHeightPoint().bind()
+
+                assertThat(pageWidth).isEqualTo(792) // 11 inches * 72 dpi
+            }
+        }
+    }
+
+    @Test
+    fun getPageCropBox() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val cropBox = page.getPageCropBox().bind()
+
+                assertThat(cropBox).isEqualTo(noResultRect)
+            }
+        }
+    }
+
+    @Test
+    fun getPageMediaBox() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val mediaBox = page.getPageMediaBox().bind()
+
+                assertThat(mediaBox).isEqualTo(RectF(0.0f, 0.0f, 612.0f, 792.0f))
+            }
+        }
+    }
+
+    @Test
+    fun getPageBleedBox() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val bleedBox = page.getPageBleedBox().bind()
+
+                assertThat(bleedBox).isEqualTo(noResultRect)
+            }
+        }
+    }
+
+    @Test
+    fun getPageTrimBox() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val trimBox = page.getPageTrimBox().bind()
+
+                assertThat(trimBox).isEqualTo(noResultRect)
+            }
+        }
+    }
+
+    @Test
+    fun getPageArtBox() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val artBox = page.getPageArtBox().bind()
+
+                assertThat(artBox).isEqualTo(noResultRect)
+            }
+        }
+    }
+
+    @Test
+    fun getPageBoundingBox() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val artBox = page.getPageBoundingBox().bind()
+
+                assertThat(artBox).isEqualTo(RectF(0f, 792f, 612f, 0f))
+            }
+        }
+    }
+
+    @Test
+    fun getPageSize() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val size = page.getPageSize(72).bind()
+
+                assertThat(size).isEqualTo(Size(612, 792))
+            }
+        }
+    }
+
+    @Test
+    fun renderPage() = runTest {
+        // I really don't know how to test it
+    }
+
+    @Test
+    fun testRenderPage() = runTest {
+        // I really don't know how to test it
+    }
+
+    @Test
+    fun renderPageBitmap() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+
+                val conf = Bitmap.Config.RGB_565 // see other conf types
+
+                val bmp = Bitmap.createBitmap(612, 792, conf) // this creates a MUTABLE bitmap
+
+                page.renderPageBitmap(bmp, 0, 0, 612, 792)
+
+                // How to verify that it's correct?
+                // Even if we don't verify the bitmap, we can check that it doesn't crash
+            }
+        }
+    }
+
+    @Test
+    fun testRenderPageBitmap() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+
+                val conf = Bitmap.Config.RGB_565 // see other conf types
+
+                val bmp = Bitmap.createBitmap(612, 792, conf) // this creates a MUTABLE bitmap
+
+                page.renderPageBitmap(bmp, 0, 0, 612, 792, renderAnnot = true, textMask = true)
+
+                // How to verify that it's correct?
+                // Even if we don't verify the bitmap, we can check that it doesn't crash
+            }
+        }
+    }
+
+    @Test
+    fun getPageLinks() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val links = page.getPageLinks().bind()
+
+                assertThat(links.size).isEqualTo(0) // The test doc doesn't have links
+            }
+        }
+    }
+
+    @Test
+    fun mapPageCoordsToDevice() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val devicePt = page.mapPageCoordsToDevice(0, 0, 100, 100, 0, 0.0, 0.0).bind()
+
+                assertThat(devicePt).isEqualTo(Point(0, 100))
+            }
+        }
+    }
+
+    @Test
+    fun mapDeviceCoordsToPage() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val devicePt = page.mapDeviceCoordsToPage(0, 0, 100, 100, 0, 0, 0).bind()
+
+                assertThat(devicePt).isEqualTo(PointF(0f, 792.00006f))
+            }
+        }
+    }
+
+    @Test
+    fun mapRectToDevice() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val devicePt = page.mapRectToDevice(0, 0, 100, 100, 0, RectF(0f, 0f, 100f, 100f)).bind()
+
+                assertThat(devicePt).isEqualTo(
+                    Rect(
+                        0, // 0f in coords to 0f in device
+                        100, // 0f in corrds in at the bottom, the bottom of the device is 100f
+                        16, // 100f in coords = 100f/(8.5*72) * 100f = 16f
+                        87
+                    ) // 100f in coords = 100 - 100f/(11*72) * 100f = 87f
+                )
+            }
+        }
+    }
+
+    @Test
+    fun mapRectToPage() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                val devicePt = page.mapRectToPage(0, 0, 100, 100, 0, Rect(0, 0, 100, 100)).bind()
+
+                assertThat(devicePt).isEqualTo(
+                    RectF(0.0f, 792.00006f, 612.0f, 0.0f)
+                )
+            }
+        }
+    }
+
+    fun close() = runTest {
+        either {
+            var pageAfterClose: PdfPageKtF?
+            pdfDocument.openPage(0).bind().use { page ->
+                pageAfterClose = page
+            }
+            pageAfterClose!!.getPageWidth(72)
+        }.mapLeft {
+            assertThat(it).isInstanceOf(PdfiumKtFErrors.AlreadyClosed::class.java)
+        }
+    }
+
+    @Test
+    fun getPage() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                assertThat(page).isNotNull()
+            }
+        }
+    }
+}
diff --git a/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfTextPageKtTest.kt b/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfTextPageKtTest.kt
new file mode 100644
index 0000000..de73c03
--- /dev/null
+++ b/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfTextPageKtTest.kt
@@ -0,0 +1,186 @@
+package io.legere.pdfiumandroid.arrow
+
+import android.graphics.RectF
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import arrow.core.raise.either
+import com.google.common.truth.Truth
+import junit.framework.TestCase
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class PdfTextPageKtTest : BasePDFTest() {
+
+    private lateinit var pdfDocument: PdfDocumentKtF
+    private var pdfBytes: ByteArray? = null
+
+    @Before
+    fun setUp() = runBlocking {
+        pdfBytes = getPdfBytes("f01.pdf")
+
+        TestCase.assertNotNull(pdfBytes)
+
+        pdfDocument = PdfiumCoreKtF(Dispatchers.Unconfined).newDocument(pdfBytes).getOrNull()!!
+    }
+
+    @After
+    fun tearDown() {
+        pdfDocument.close()
+    }
+
+    @Test
+    fun textPageCountChars() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                page.openTextPage().bind().use { textPage ->
+                    val charCount = textPage.textPageCountChars().bind()
+
+                    Truth.assertThat(charCount).isEqualTo(3468)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun textPageGetText() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                page.openTextPage().bind().use { textPage ->
+                    val text = textPage.textPageGetText(0, 100).bind()
+
+                    Truth.assertThat(text?.length).isEqualTo(100)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun textPageGetUnicode() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                page.openTextPage().bind().use { textPage ->
+                    val char = textPage.textPageGetUnicode(0).bind()
+
+                    Truth.assertThat(char).isEqualTo('T')
+                }
+            }
+        }
+    }
+
+    @Test
+    fun textPageGetCharBox() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                page.openTextPage().bind().use { textPage ->
+                    val rect = textPage.textPageGetCharBox(0).bind()
+
+                    Truth.assertThat(rect)
+                        .isEqualTo(RectF(90.314415f, 715.3187f, 103.44171f, 699.1206f))
+                }
+            }
+        }
+    }
+
+    @Test
+    fun textPageGetCharIndexAtPos() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                page.openTextPage().bind().use { textPage ->
+                    val characterToLookup = 0
+                    val rect = textPage.textPageGetCharBox(characterToLookup).bind()
+
+                    val pos = textPage.textPageGetCharIndexAtPos(
+                        rect?.centerX()?.toDouble() ?: 0.0,
+                        rect?.centerY()?.toDouble() ?: 0.0,
+                        1.0, // Shouldn't need much since we're in the middle of the rect
+                        1.0
+                    ).bind()
+
+                    Truth.assertThat(pos).isEqualTo(characterToLookup)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun textPageCountRects() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                page.openTextPage().bind().use { textPage ->
+                    val rectCount = textPage.textPageCountRects(0, 100).bind()
+
+                    Truth.assertThat(rectCount).isEqualTo(4)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun textPageGetRect() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                page.openTextPage().bind().use { textPage ->
+                    val rect = textPage.textPageGetRect(0).bind()
+
+                    Truth.assertThat(rect).isEqualTo(RectF(0f, 0f, 0f, 0f))
+                }
+            }
+        }
+    }
+
+    @Test
+    fun textPageGetBoundedText() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                page.openTextPage().bind().use { textPage ->
+                    val text = textPage.textPageGetBoundedText(RectF(0f, 97f, 100f, 100f), 100).bind()
+
+                    Truth.assertThat(text).isEqualTo("Do")
+                }
+            }
+        }
+    }
+
+    @Test
+    fun getFontSize() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                page.openTextPage().bind().use { textPage ->
+                    val fontSize = textPage.getFontSize(0).bind()
+
+                    Truth.assertThat(fontSize).isEqualTo(22.559999465942383)
+                }
+            }
+        }
+    }
+
+    fun close() = runTest {
+        either {
+            var pageAfterClose: PdfTextPageKtF?
+            pdfDocument.openPage(0).bind().use { page ->
+                page.openTextPage().bind().use { textPage ->
+                    pageAfterClose = textPage
+                }
+            }
+            pageAfterClose!!.textPageCountChars()
+        }.mapLeft {
+            Truth.assertThat(it).isInstanceOf(PdfiumKtFErrors.AlreadyClosed::class.java)
+        }
+    }
+
+    @Test
+    fun getPage() = runTest {
+        either {
+            pdfDocument.openPage(0).bind().use { page ->
+                page.openTextPage().bind().use { textPage ->
+                    Truth.assertThat(textPage.page).isNotNull()
+                }
+            }
+        }
+    }
+}
diff --git a/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfiumCoreKtFTest.kt b/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfiumCoreKtFTest.kt
new file mode 100644
index 0000000..41bb2c4
--- /dev/null
+++ b/PdfiumAndroid/arrow/src/androidTest/java/io/legere/pdfiumandroid/arrow/PdfiumCoreKtFTest.kt
@@ -0,0 +1,24 @@
+package io.legere.pdfiumandroid.arrow
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class PdfiumCoreKtFTest : BasePDFTest() {
+
+    @Test
+    fun newDocument() = runTest {
+        val pdfBytes = getPdfBytes("f01.pdf")
+
+        Assert.assertNotNull(pdfBytes)
+
+        val pdfiumCore = PdfiumCoreKtF(Dispatchers.Unconfined)
+        val pdfDocument = pdfiumCore.newDocument(pdfBytes)
+
+        Assert.assertNotNull(pdfDocument)
+    }
+}
diff --git a/PdfiumAndroid/arrow/src/main/java/io/legere/pdfiumandroid/arrow/PdfTextPageKtF.kt b/PdfiumAndroid/arrow/src/main/java/io/legere/pdfiumandroid/arrow/PdfTextPageKtF.kt
index b2f56af..797b3e0 100644
--- a/PdfiumAndroid/arrow/src/main/java/io/legere/pdfiumandroid/arrow/PdfTextPageKtF.kt
+++ b/PdfiumAndroid/arrow/src/main/java/io/legere/pdfiumandroid/arrow/PdfTextPageKtF.kt
@@ -14,7 +14,7 @@ import java.io.Closeable
  * @property dispatcher the [CoroutineDispatcher] to use for suspending calls
  */
 @Suppress("TooManyFunctions")
-class PdfTextPageKtF(private val page: PdfTextPage, private val dispatcher: CoroutineDispatcher) : Closeable {
+class PdfTextPageKtF(val page: PdfTextPage, private val dispatcher: CoroutineDispatcher) : Closeable {
 
     /**
      * suspend version of [PdfTextPage.textPageCountChars]
diff --git a/PdfiumAndroid/arrow/src/test/java/io/legere/pdfiumandroid/arrow/ExampleUnitTest.kt b/PdfiumAndroid/arrow/src/test/java/io/legere/pdfiumandroid/arrow/ExampleUnitTest.kt
deleted file mode 100644
index b574b26..0000000
--- a/PdfiumAndroid/arrow/src/test/java/io/legere/pdfiumandroid/arrow/ExampleUnitTest.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package io.legere.pdfiumandroid.arrow
-
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-/**
- * Example local unit test, which will execute on the development machine (host).
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-class ExampleUnitTest {
-    @Test
-    fun addition_isCorrect() {
-        assertEquals(4, 2 + 2)
-    }
-}
diff --git a/README.md b/README.md
index a47d5b4..270a148 100644
--- a/README.md
+++ b/README.md
@@ -16,5 +16,5 @@ PdfDocument, PdfPage, PdfTextPage and Kt versions all uses Closable.
 
 To use it, add the following app's build.gradle:
 ```
-    implementation("io.legere:pdfiumandroid:1.0.16")
+    implementation("io.legere:pdfiumandroid:1.0.17")
 ```
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index b9c3c8f..9043f4d 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -37,6 +37,7 @@ material = { module = "com.google.android.material:material", version.ref = "mat
 timber = { module = "com.jakewharton.timber:timber", version.ref = "timber" }
 truth = { module = "com.google.truth:truth", version.ref = "truth" }
 arrow-core = { module = "io.arrow-kt:arrow-core", version.ref = "arrow" }
+arrow-fx-coroutines = { module = "io.arrow-kt:arrow-fx-coroutines", version.ref = "arrow" }
 
 [bundles]