Cut release 0.5.0

Show end of book screen when navigating past last page
Process lines into pages as they are built
2026-04-29 10:26:52 -07:00 · 2025-12-13 20:16:12 +11:00 · 2025-12-13 20:10:38 +11:00 · 2025-12-13 20:10:16 +11:00 · 2025-12-13 19:36:01 +11:00 · 2025-12-13 17:15:06 +11:00
34 changed files with 1390 additions and 616 deletions
@@ -0,0 +1,2 @@
+CompileFlags:
+    Add: [-std=c++2a]
@@ -36,7 +36,30 @@ This project is **not affiliated with Xteink**; it's built as a community projec
 - [ ] WiFi connectivity
 - [ ] BLE connectivity

-## Getting Started
+## Installing
+
+### Web (latest firmware)
+
+1. Connect your Xteink X4 to your computer via USB-C
+2. Go to https://xteink.dve.al/ and click "Flash CrossPoint firmware"
+
+To revert back to the official firmware, you can flash the latest official firmware from https://xteink.dve.al/, or swap
+back to the other partition using the "Swap boot partition" button here https://xteink.dve.al/debug.
+
+### Web (specific firmware version)
+
+1. Connect your Xteink X4 to your computer via USB-C
+2. Download the `firmware.bin` file from the release of your choice via the [releases page](https://github.com/daveallie/crosspoint-reader/releases)
+3. Go to https://xteink.dve.al/ and flash the firmware file using the "OTA fast flash controls" section
+
+To revert back to the official firmware, you can flash the latest official firmware from https://xteink.dve.al/, or swap
+back to the other partition using the "Swap boot partition" button here https://xteink.dve.al/debug.
+
+### Manual
+
+See [Development](#development) below.
+
+## Development

 ### Prerequisites

@@ -58,24 +81,12 @@ git submodule update --init --recursive

 ### Flashing your device

-#### Command line
-
 Connect your Xteink X4 to your computer via USB-C and run the following command.

 ```sh
 pio run --target upload
 ```

-#### Web
-
-1. Connect your Xteink X4 to your computer via USB-C
-2. Download the `firmware.bin` file from the latest release via the [releases page](https://github.com/daveallie/crosspoint-reader/releases)
-3. Go to https://xteink.dve.al/ and flash the firmware file using the "OTA fast flash controls" section
-4. Press the reset button on the Xteink X4 to restart the device
-
-To revert back to the official firmware, you can flash the latest official firmware from https://xteink.dve.al/, or swap
-back to the other partition using the "Swap boot partition" button here https://xteink.dve.al/debug. 
-
 ## Internals

 CrossPoint Reader is pretty aggressive about caching data down to the SD card to minimise RAM usage. The ESP32-C3 only
@@ -0,0 +1,184 @@
+/**
+ * generated by fontconvert.py
+ * name: pixelarial14
+ * size: 8
+ * mode: 1-bit
+ */
+#pragma once
+#include "EpdFontData.h"
+
+static const uint8_t pixelarial14Bitmaps[1145] = {
+    0xFF, 0xFF, 0xFF, 0xC0, 0xFF, 0xFF, 0xFF, 0x1C, 0x63, 0x8C, 0xF7, 0x98, 0xCF, 0xFF, 0xFF, 0xDC, 0xE7, 0xFE, 0xFF,
+    0xFF, 0xFB, 0x9C, 0x63, 0x0C, 0x60, 0x30, 0xF3, 0xFF, 0xBF, 0x1F, 0x9F, 0x9B, 0x37, 0xEF, 0xFB, 0xE3, 0x00, 0x70,
+    0x67, 0xCF, 0x37, 0x61, 0xBB, 0x0D, 0xF0, 0x7D, 0x81, 0xDD, 0xC0, 0xDF, 0x07, 0x98, 0xFC, 0xC7, 0x66, 0x7B, 0xF3,
+    0x07, 0x00, 0x3E, 0x0F, 0xE1, 0x8C, 0x31, 0x86, 0x60, 0xFC, 0x1F, 0x07, 0xE4, 0xC7, 0x98, 0xF3, 0x0E, 0x7F, 0xF7,
+    0xE6, 0xFF, 0xF0, 0x37, 0x66, 0xCC, 0xCC, 0xCC, 0xCC, 0xC6, 0x67, 0x30, 0xCE, 0x66, 0x33, 0x33, 0x33, 0x33, 0x36,
+    0x6E, 0xC0, 0x6F, 0xF6, 0xFF, 0x08, 0x0E, 0x07, 0x03, 0x8F, 0xFF, 0xFC, 0x70, 0x38, 0x1C, 0x0E, 0x00, 0xFF, 0xC0,
+    0xFB, 0xFF, 0x80, 0xF0, 0x1C, 0x73, 0xCC, 0x30, 0xC7, 0x18, 0x61, 0x8E, 0x30, 0xC0, 0x7E, 0xFF, 0xC3, 0xC3, 0xC3,
+    0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0x37, 0xFF, 0x33, 0x33, 0x33, 0x33, 0x30, 0x7E, 0xFF, 0xC3, 0xC3,
+    0x03, 0x03, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xFF, 0xFF, 0x7E, 0xFF, 0xC3, 0xC3, 0x03, 0x3F, 0x3F, 0x03, 0x03, 0xC3,
+    0xC3, 0xFF, 0x7E, 0x03, 0x03, 0x83, 0xC3, 0xE3, 0x31, 0x99, 0xCD, 0xC6, 0xC3, 0x7F, 0xFF, 0xE0, 0x60, 0x30, 0x7F,
+    0x7F, 0xE0, 0xC0, 0xFE, 0xFF, 0xC3, 0x03, 0x03, 0xC3, 0xC7, 0xFE, 0x7E, 0x7E, 0xFF, 0xC3, 0xC0, 0xC0, 0xFE, 0xFF,
+    0xE3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0xFF, 0xFF, 0x07, 0x06, 0x06, 0x1E, 0x1C, 0x1C, 0x1C, 0x38, 0x30, 0x30, 0x30,
+    0x7E, 0xFF, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0x7E, 0xFF, 0xC3, 0xC3, 0xC3, 0xC7,
+    0xFF, 0x7F, 0x03, 0x03, 0xC7, 0xFE, 0x7C, 0xF0, 0x00, 0x3C, 0xF0, 0x00, 0x3F, 0xF0, 0x03, 0x03, 0x1E, 0x7E, 0xF0,
+    0xF0, 0x70, 0x7E, 0x1F, 0x03, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xC0, 0xC0, 0x70, 0x7E, 0x1F, 0x0F, 0x1E, 0x7E,
+    0xF0, 0xC0, 0x7E, 0xFF, 0xC3, 0xC3, 0x03, 0x07, 0x1E, 0x1C, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3F, 0x87, 0xFE, 0xFF,
+    0x7D, 0xFB, 0xF1, 0xBF, 0x1B, 0xF3, 0xBF, 0xFF, 0xDF, 0xE6, 0x00, 0x7F, 0x03, 0xF0, 0x06, 0x01, 0xF0, 0x1F, 0x01,
+    0xF0, 0x1F, 0x03, 0xB8, 0x31, 0x87, 0xFC, 0x7F, 0xE7, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x30, 0xFF, 0x7F, 0xF0, 0x78,
+    0x3C, 0x1F, 0xFF, 0xFF, 0x83, 0xC1, 0xE0, 0xF0, 0x7F, 0xFF, 0xF0, 0x3F, 0x0F, 0xF3, 0x87, 0xE0, 0x3C, 0x01, 0x80,
+    0x30, 0x06, 0x00, 0xC0, 0x18, 0x0F, 0x87, 0xBF, 0xC3, 0xF0, 0xFF, 0x1F, 0xF3, 0x07, 0xE0, 0x3C, 0x07, 0x80, 0xF0,
+    0x1E, 0x03, 0xC0, 0x78, 0x0F, 0x07, 0xFF, 0xCF, 0xF0, 0xFF, 0xFF, 0xF0, 0x18, 0x0C, 0x07, 0xFF, 0xFF, 0x80, 0xC0,
+    0x60, 0x30, 0x1F, 0xFF, 0xF8, 0xFF, 0xFF, 0xF0, 0x18, 0x0C, 0x07, 0xFB, 0xFD, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C,
+    0x00, 0x3F, 0x87, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x0C, 0x00, 0xC1, 0xFC, 0x1F, 0xC0, 0x3C, 0x03, 0xE0, 0x77, 0xFE,
+    0x3F, 0x80, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1F, 0xFF, 0xFF, 0x83, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x18, 0xFF, 0xFF,
+    0xFF, 0xC0, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x07, 0x8F, 0x1F, 0xF7, 0xC0, 0xC0, 0x78, 0x3F, 0x0E, 0x61,
+    0x8C, 0x61, 0xBC, 0x3F, 0x87, 0xB8, 0xE3, 0x1C, 0x63, 0x0E, 0x60, 0xFC, 0x06, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06,
+    0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x1F, 0xFF, 0xF8, 0xC0, 0x3E, 0x07, 0xE0, 0x7E, 0x07, 0xF1, 0xBF, 0x1B, 0xFB,
+    0xBD, 0xF3, 0xDF, 0x3D, 0xF3, 0xDF, 0x3C, 0x63, 0xC6, 0x30, 0xC1, 0xF0, 0xFC, 0x7E, 0x3F, 0x1F, 0xEF, 0x77, 0xBB,
+    0xC7, 0xE3, 0xF1, 0xF8, 0x7C, 0x18, 0x3F, 0x87, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0,
+    0x3C, 0x03, 0xE0, 0x77, 0xFE, 0x3F, 0x80, 0xFF, 0x7F, 0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0xFF, 0xFE, 0xC0, 0x60, 0x30,
+    0x18, 0x0C, 0x00, 0x3F, 0x87, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x37, 0xE3,
+    0xE7, 0xFF, 0x3F, 0x70, 0xFF, 0x9F, 0xFF, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xFF, 0xFF, 0xFC, 0xC6, 0x18, 0xE3, 0x0E,
+    0x60, 0xFC, 0x06, 0x7F, 0x7F, 0xF0, 0x78, 0x3C, 0x07, 0xE1, 0xFE, 0x0F, 0x01, 0xE0, 0xF0, 0x7F, 0xF7, 0xF0, 0xFF,
+    0xFF, 0xC7, 0x03, 0x81, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81, 0xC0, 0xC1, 0xE0, 0xF0, 0x78, 0x3C,
+    0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF8, 0xEF, 0xE3, 0xE0, 0xC0, 0x3C, 0x03, 0xE0, 0x76, 0x06, 0x60, 0x67, 0x1E,
+    0x31, 0x83, 0xB8, 0x1F, 0x01, 0xF0, 0x1F, 0x00, 0x60, 0x06, 0x00, 0xC1, 0x81, 0xE1, 0xF0, 0xF8, 0xD8, 0xEC, 0x6C,
+    0x66, 0x36, 0x33, 0x1B, 0x19, 0xDD, 0xFC, 0x6C, 0x7C, 0x36, 0x3E, 0x1B, 0x1F, 0x0F, 0x8F, 0x03, 0x83, 0x01, 0xC1,
+    0x80, 0xC0, 0x7C, 0x3D, 0x86, 0x30, 0xC3, 0x30, 0x7E, 0x07, 0x80, 0xF8, 0x33, 0x0E, 0x71, 0x86, 0x70, 0xFC, 0x06,
+    0xC0, 0x3E, 0x07, 0x71, 0xE3, 0x18, 0x31, 0x83, 0xF8, 0x1F, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06,
+    0x00, 0xFF, 0xFF, 0xFC, 0x0E, 0x01, 0x80, 0x30, 0x0E, 0x07, 0x80, 0xE0, 0x30, 0x06, 0x01, 0xC0, 0x7F, 0xFF, 0xFE,
+    0xFF, 0x6D, 0xB6, 0xDB, 0x6D, 0xB7, 0xE0, 0xC3, 0x0E, 0x18, 0x61, 0x87, 0x0C, 0x30, 0xC3, 0x87, 0x1C, 0xFD, 0xB6,
+    0xDB, 0x6D, 0xB6, 0xDF, 0xE0, 0x30, 0xF1, 0xF3, 0xE7, 0xDD, 0xF1, 0x80, 0xFF, 0xFF, 0xFC, 0xCE, 0x73, 0x00, 0x7E,
+    0x7E, 0xC3, 0xC3, 0x3F, 0x7F, 0x63, 0xE3, 0xC7, 0xFF, 0x7F, 0xC0, 0xC0, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3,
+    0xC3, 0xE3, 0xFF, 0xFE, 0x78, 0xFB, 0x1E, 0x3C, 0x18, 0x30, 0x60, 0xC7, 0xFD, 0xF0, 0x03, 0x03, 0x7B, 0x7F, 0xC7,
+    0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7F, 0x7E, 0x7E, 0xC3, 0xC3, 0xFF, 0xFF, 0xC0, 0xC0, 0xC3, 0xFF, 0x7E,
+    0x3D, 0xEF, 0xBF, 0x61, 0x86, 0x18, 0x61, 0x86, 0x18, 0x60, 0x7B, 0x7F, 0xC7, 0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7,
+    0xFF, 0x7F, 0x03, 0xC3, 0xFF, 0x7E, 0xC0, 0xC0, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+    0xFF, 0xFF, 0xFF, 0xC0, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0xE0, 0xC0, 0xC0, 0xC3, 0xC3, 0xC6, 0xDE,
+    0xFC, 0xF8, 0xFC, 0xEE, 0xC6, 0xC7, 0xC3, 0xFF, 0xFF, 0xFF, 0xC0, 0xF9, 0xEF, 0xDE, 0xE7, 0x3E, 0x73, 0xC6, 0x3C,
+    0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x30, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+    0xC3, 0x7E, 0x7E, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3,
+    0xC3, 0xE3, 0xFF, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0x7B, 0x7F, 0xC7, 0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7F,
+    0x03, 0x03, 0x03, 0x03, 0xFB, 0xFE, 0x38, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x00, 0x78, 0xFB, 0x1E, 0x3F, 0x8F, 0x81,
+    0x83, 0xC7, 0xFD, 0xF0, 0x61, 0x8F, 0xBF, 0x61, 0x86, 0x18, 0x61, 0x86, 0x1E, 0x7C, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+    0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7F, 0xC1, 0xE0, 0xF0, 0x7C, 0x76, 0x33, 0xB8, 0xD8, 0x6C, 0x3E, 0x0E, 0x07, 0x00,
+    0xC6, 0x3C, 0x63, 0xC6, 0x3F, 0xF7, 0x7F, 0x67, 0xF6, 0x7F, 0x67, 0xF6, 0x7B, 0xE3, 0x18, 0x31, 0x80, 0xC3, 0xC3,
+    0x66, 0x66, 0x7E, 0x3C, 0x3C, 0x7E, 0x66, 0xE7, 0xC3, 0xC1, 0xE0, 0xF0, 0x7C, 0x76, 0x33, 0xB8, 0xD8, 0x6C, 0x36,
+    0x1F, 0x07, 0x03, 0x81, 0xC3, 0xE1, 0xC0, 0xFF, 0xFF, 0x06, 0x1E, 0x1C, 0x1C, 0x30, 0x30, 0x70, 0xFF, 0xFF, 0x37,
+    0x66, 0x66, 0x6E, 0xCE, 0x66, 0x66, 0x67, 0x30, 0xFF, 0xFF, 0xFF, 0xC0, 0xCE, 0x66, 0x66, 0x67, 0x37, 0x66, 0x66,
+    0x6E, 0xC0, 0xC3, 0x9B, 0xFF, 0xF9, 0xB8, 0x30, 0xDB, 0x66, 0xC0, 0x6D, 0xBD, 0x80, 0x7F, 0xEF, 0x3C, 0xF3, 0xC0,
+    0x7D, 0xF7, 0xDF, 0xF3, 0xC0,
+};
+
+static const EpdGlyph pixelarial14Glyphs[] = {
+    {0, 0, 4, 0, 0, 0, 0},          //
+    {2, 13, 3, 0, 13, 4, 0},        // !
+    {4, 6, 5, 0, 13, 3, 4},         // "
+    {11, 13, 12, 0, 13, 18, 7},     // #
+    {7, 13, 8, 0, 13, 12, 25},      // $
+    {13, 13, 14, 0, 13, 22, 37},    // %
+    {11, 13, 12, 0, 13, 18, 59},    // &
+    {2, 6, 3, 0, 13, 2, 77},        // '
+    {4, 17, 5, 0, 13, 9, 79},       // (
+    {4, 17, 5, 0, 13, 9, 88},       // )
+    {4, 6, 5, 0, 13, 3, 97},        // *
+    {9, 10, 10, 0, 11, 12, 100},    // +
+    {2, 5, 3, 0, 2, 2, 112},        // ,
+    {6, 3, 6, 0, 6, 3, 114},        // -
+    {2, 2, 3, 0, 2, 1, 117},        // .
+    {6, 13, 6, 0, 13, 10, 118},     // /
+    {8, 13, 9, 0, 13, 13, 128},     // 0
+    {4, 13, 5, 0, 13, 7, 141},      // 1
+    {8, 13, 9, 0, 13, 13, 148},     // 2
+    {8, 13, 9, 0, 13, 13, 161},     // 3
+    {9, 13, 10, 0, 13, 15, 174},    // 4
+    {8, 13, 9, 0, 13, 13, 189},     // 5
+    {8, 13, 9, 0, 13, 13, 202},     // 6
+    {8, 13, 9, 0, 13, 13, 215},     // 7
+    {8, 13, 9, 0, 13, 13, 228},     // 8
+    {8, 13, 9, 0, 13, 13, 241},     // 9
+    {2, 11, 3, 0, 11, 3, 254},      // :
+    {2, 14, 3, 0, 11, 4, 257},      // ;
+    {8, 10, 9, 0, 11, 10, 261},     // <
+    {8, 6, 9, 0, 9, 6, 271},        // =
+    {8, 10, 9, 0, 11, 10, 277},     // >
+    {8, 13, 9, 0, 13, 13, 287},     // ?
+    {12, 12, 13, 0, 9, 18, 300},    // @
+    {12, 13, 13, 0, 13, 20, 318},   // A
+    {9, 13, 10, 0, 13, 15, 338},    // B
+    {11, 13, 12, 0, 13, 18, 353},   // C
+    {11, 13, 12, 0, 13, 18, 371},   // D
+    {9, 13, 10, 0, 13, 15, 389},    // E
+    {9, 13, 10, 0, 13, 15, 404},    // F
+    {12, 13, 13, 0, 13, 20, 419},   // G
+    {9, 13, 10, 0, 13, 15, 439},    // H
+    {2, 13, 3, 0, 13, 4, 454},      // I
+    {7, 13, 8, 0, 13, 12, 458},     // J
+    {11, 13, 12, 0, 13, 18, 470},   // K
+    {9, 13, 10, 0, 13, 15, 488},    // L
+    {12, 13, 13, 0, 13, 20, 503},   // M
+    {9, 13, 10, 0, 13, 15, 523},    // N
+    {12, 13, 13, 0, 13, 20, 538},   // O
+    {9, 13, 10, 0, 13, 15, 558},    // P
+    {12, 13, 13, 0, 13, 20, 573},   // Q
+    {11, 13, 12, 0, 13, 18, 593},   // R
+    {9, 13, 10, 0, 13, 15, 611},    // S
+    {9, 13, 10, 0, 13, 15, 626},    // T
+    {9, 13, 10, 0, 13, 15, 641},    // U
+    {12, 13, 13, 0, 13, 20, 656},   // V
+    {17, 13, 18, 0, 13, 28, 676},   // W
+    {11, 13, 12, 0, 13, 18, 704},   // X
+    {12, 13, 13, 0, 13, 20, 722},   // Y
+    {11, 13, 12, 0, 13, 18, 742},   // Z
+    {3, 17, 4, 0, 13, 7, 760},      // [
+    {6, 13, 6, 0, 13, 10, 767},     // <backslash>
+    {3, 17, 4, 0, 13, 7, 777},      // ]
+    {7, 7, 8, 0, 13, 7, 784},       // ^
+    {11, 2, 12, 0, 2, 3, 791},      // _
+    {4, 5, 5, 0, 13, 3, 794},       // `
+    {8, 11, 9, 0, 11, 11, 797},     // a
+    {8, 13, 9, 0, 13, 13, 808},     // b
+    {7, 11, 8, 0, 11, 10, 821},     // c
+    {8, 13, 9, 0, 13, 13, 831},     // d
+    {8, 11, 9, 0, 11, 11, 844},     // e
+    {6, 13, 6, 0, 13, 10, 855},     // f
+    {8, 15, 9, 0, 11, 15, 865},     // g
+    {8, 13, 9, 0, 13, 13, 880},     // h
+    {2, 13, 3, 0, 13, 4, 893},      // i
+    {4, 17, 5, 0, 13, 9, 897},      // j
+    {8, 13, 9, 0, 13, 13, 906},     // k
+    {2, 13, 3, 0, 13, 4, 919},      // l
+    {12, 11, 13, 0, 11, 17, 923},   // m
+    {8, 11, 9, 0, 11, 11, 940},     // n
+    {8, 11, 9, 0, 11, 11, 951},     // o
+    {8, 15, 9, 0, 11, 15, 962},     // p
+    {8, 15, 9, 0, 11, 15, 977},     // q
+    {6, 11, 6, 0, 11, 9, 992},      // r
+    {7, 11, 8, 0, 11, 10, 1001},    // s
+    {6, 13, 6, 0, 13, 10, 1011},    // t
+    {8, 11, 9, 0, 11, 11, 1021},    // u
+    {9, 11, 10, 0, 11, 13, 1032},   // v
+    {12, 11, 13, 0, 11, 17, 1045},  // w
+    {8, 11, 9, 0, 11, 11, 1062},    // x
+    {9, 15, 10, 0, 11, 17, 1073},   // y
+    {8, 11, 9, 0, 11, 11, 1090},    // z
+    {4, 17, 5, 0, 13, 9, 1101},     // {
+    {2, 13, 3, 0, 13, 4, 1110},     // |
+    {4, 17, 5, 0, 13, 9, 1114},     // }
+    {11, 4, 12, 0, 9, 6, 1123},     // ~
+    {3, 6, 4, 0, 13, 3, 1129},      // ‘
+    {3, 6, 4, 0, 13, 3, 1132},      // ’
+    {6, 6, 6, 0, 13, 5, 1135},      // “
+    {6, 6, 6, 0, 13, 5, 1140},      // ”
+};
+
+static const EpdUnicodeInterval pixelarial14Intervals[] = {
+    {0x20, 0x7E, 0x0},
+    {0x2018, 0x2019, 0x5F},
+    {0x201C, 0x201D, 0x61},
+};
+
+static const EpdFontData pixelarial14 = {
+    pixelarial14Bitmaps, pixelarial14Glyphs, pixelarial14Intervals, 3, 17, 13, -4, false,
+};
@@ -6,250 +6,166 @@

 #include <map>

-bool Epub::findContentOpfFile(const ZipFile& zip, std::string& contentOpfFile) {
-  // open up the meta data to find where the content.opf file lives
-  size_t s;
-  const auto metaInfo = reinterpret_cast<char*>(zip.readFileToMemory("META-INF/container.xml", &s, true));
-  if (!metaInfo) {
-    Serial.printf("[%lu] [EBP] Could not find META-INF/container.xml\n", millis());
+#include "Epub/FsHelpers.h"
+#include "Epub/parsers/ContainerParser.h"
+#include "Epub/parsers/ContentOpfParser.h"
+#include "Epub/parsers/TocNcxParser.h"
+
+bool Epub::findContentOpfFile(std::string* contentOpfFile) const {
+  const auto containerPath = "META-INF/container.xml";
+  size_t containerSize;
+
+  // Get file size without loading it all into heap
+  if (!getItemSize(containerPath, &containerSize)) {
+    Serial.printf("[%lu] [EBP] Could not find or size META-INF/container.xml\n", millis());
    return false;
  }

-  // parse the meta data
-  tinyxml2::XMLDocument metaDataDoc;
-  const auto result = metaDataDoc.Parse(metaInfo);
-  free(metaInfo);
+  ContainerParser containerParser(containerSize);

-  if (result != tinyxml2::XML_SUCCESS) {
-    Serial.printf("[%lu] [EBP] Could not parse META-INF/container.xml. Error: %d\n", millis(), result);
+  if (!containerParser.setup()) {
    return false;
  }

-  const auto container = metaDataDoc.FirstChildElement("container");
-  if (!container) {
-    Serial.printf("[%lu] [EBP] Could not find container element in META-INF/container.xml\n", millis());
+  // Stream read (reusing your existing stream logic)
+  if (!readItemContentsToStream(containerPath, containerParser, 512)) {
+    Serial.printf("[%lu] [EBP] Could not read META-INF/container.xml\n", millis());
+    containerParser.teardown();
    return false;
  }

-  const auto rootfiles = container->FirstChildElement("rootfiles");
-  if (!rootfiles) {
-    Serial.printf("[%lu] [EBP] Could not find rootfiles element in META-INF/container.xml\n", millis());
+  // Extract the result
+  if (containerParser.fullPath.empty()) {
+    Serial.printf("[%lu] [EBP] Could not find valid rootfile in container.xml\n", millis());
+    containerParser.teardown();
    return false;
  }

-  // find the root file that has the media-type="application/oebps-package+xml"
-  auto rootfile = rootfiles->FirstChildElement("rootfile");
-  while (rootfile) {
-    const char* mediaType = rootfile->Attribute("media-type");
-    if (mediaType && strcmp(mediaType, "application/oebps-package+xml") == 0) {
-      const char* full_path = rootfile->Attribute("full-path");
-      if (full_path) {
-        contentOpfFile = full_path;
-        return true;
-      }
-    }
-    rootfile = rootfile->NextSiblingElement("rootfile");
-  }
+  *contentOpfFile = std::move(containerParser.fullPath);

-  Serial.printf("[%lu] [EBP] Could not get path to content.opf file\n", millis());
-  return false;
-}
-
-bool Epub::parseContentOpf(ZipFile& zip, std::string& content_opf_file) {
-  // read in the content.opf file and parse it
-  auto contents = reinterpret_cast<char*>(zip.readFileToMemory(content_opf_file.c_str(), nullptr, true));
-
-  // parse the contents
-  tinyxml2::XMLDocument doc;
-  auto result = doc.Parse(contents);
-  free(contents);
-
-  if (result != tinyxml2::XML_SUCCESS) {
-    Serial.printf("[%lu] [EBP] Error parsing content.opf - %s\n", millis(),
-                  tinyxml2::XMLDocument::ErrorIDToName(result));
-    return false;
-  }
-
-  auto package = doc.FirstChildElement("package");
-  if (!package) package = doc.FirstChildElement("opf:package");
-
-  if (!package) {
-    Serial.printf("[%lu] [EBP] Could not find package element in content.opf\n", millis());
-    return false;
-  }
-
-  // get the metadata - title and cover image
-  auto metadata = package->FirstChildElement("metadata");
-  if (!metadata) metadata = package->FirstChildElement("opf:metadata");
-  if (!metadata) {
-    Serial.printf("[%lu] [EBP] Missing metadata\n", millis());
-    return false;
-  }
-
-  auto titleEl = metadata->FirstChildElement("dc:title");
-  if (!titleEl) {
-    Serial.printf("[%lu] [EBP] Missing title\n", millis());
-    return false;
-  }
-  this->title = titleEl->GetText();
-
-  auto cover = metadata->FirstChildElement("meta");
-  if (!cover) cover = metadata->FirstChildElement("opf:meta");
-  while (cover && cover->Attribute("name") && strcmp(cover->Attribute("name"), "cover") != 0) {
-    cover = cover->NextSiblingElement("meta");
-  }
-  if (!cover) {
-    Serial.printf("[%lu] [EBP] Missing cover\n", millis());
-  }
-  auto coverItem = cover ? cover->Attribute("content") : nullptr;
-
-  // read the manifest and spine
-  // the manifest gives us the names of the files
-  // the spine gives us the order of the files
-  // we can then read the files in the order they are in the spine
-  auto manifest = package->FirstChildElement("manifest");
-  if (!manifest) manifest = package->FirstChildElement("opf:manifest");
-  if (!manifest) {
-    Serial.printf("[%lu] [EBP] Missing manifest\n", millis());
-    return false;
-  }
-
-  // create a mapping from id to file name
-  auto item = manifest->FirstChildElement("item");
-  if (!item) item = manifest->FirstChildElement("opf:item");
-  std::map<std::string, std::string> items;
-
-  while (item) {
-    std::string itemId = item->Attribute("id");
-    std::string href = contentBasePath + item->Attribute("href");
-
-    // grab the cover image
-    if (coverItem && itemId == coverItem) {
-      coverImageItem = href;
-    }
-
-    // grab the ncx file
-    if (itemId == "ncx" || itemId == "ncxtoc") {
-      tocNcxItem = href;
-    }
-
-    items[itemId] = href;
-    auto nextItem = item->NextSiblingElement("item");
-    if (!nextItem) nextItem = item->NextSiblingElement("opf:item");
-    item = nextItem;
-  }
-
-  // find the spine
-  auto spineEl = package->FirstChildElement("spine");
-  if (!spineEl) spineEl = package->FirstChildElement("opf:spine");
-  if (!spineEl) {
-    Serial.printf("[%lu] [EBP] Missing spine\n", millis());
-    return false;
-  }
-
-  // read the spine
-  auto itemref = spineEl->FirstChildElement("itemref");
-  if (!itemref) itemref = spineEl->FirstChildElement("opf:itemref");
-  while (itemref) {
-    auto id = itemref->Attribute("idref");
-    if (items.find(id) != items.end()) {
-      spine.emplace_back(id, items[id]);
-    }
-    auto nextItemRef = itemref->NextSiblingElement("itemref");
-    if (!nextItemRef) nextItemRef = itemref->NextSiblingElement("opf:itemref");
-    itemref = nextItemRef;
-  }
+  containerParser.teardown();
  return true;
 }

-bool Epub::parseTocNcxFile(const ZipFile& zip) {
+bool Epub::parseContentOpf(const std::string& contentOpfFilePath) {
+  size_t contentOpfSize;
+  if (!getItemSize(contentOpfFilePath, &contentOpfSize)) {
+    Serial.printf("[%lu] [EBP] Could not get size of content.opf\n", millis());
+    return false;
+  }
+
+  ContentOpfParser opfParser(getBasePath(), contentOpfSize);
+
+  if (!opfParser.setup()) {
+    Serial.printf("[%lu] [EBP] Could not setup content.opf parser\n", millis());
+    return false;
+  }
+
+  if (!readItemContentsToStream(contentOpfFilePath, opfParser, 1024)) {
+    Serial.printf("[%lu] [EBP] Could not read content.opf\n", millis());
+    opfParser.teardown();
+    return false;
+  }
+
+  // Grab data from opfParser into epub
+  title = opfParser.title;
+
+  if (opfParser.items.count("ncx")) {
+    tocNcxItem = opfParser.items.at("ncx");
+  } else if (opfParser.items.count("ncxtoc")) {
+    tocNcxItem = opfParser.items.at("ncxtoc");
+  }
+
+  for (auto& spineRef : opfParser.spineRefs) {
+    if (opfParser.items.count(spineRef)) {
+      spine.emplace_back(spineRef, opfParser.items.at(spineRef));
+    }
+  }
+
+  Serial.printf("[%lu] [EBP] Successfully parsed content.opf\n", millis());
+
+  opfParser.teardown();
+  return true;
+}
+
+bool Epub::parseTocNcxFile() {
  // the ncx file should have been specified in the content.opf file
  if (tocNcxItem.empty()) {
    Serial.printf("[%lu] [EBP] No ncx file specified\n", millis());
    return false;
  }

-  const auto ncxData = reinterpret_cast<char*>(zip.readFileToMemory(tocNcxItem.c_str(), nullptr, true));
-  if (!ncxData) {
-    Serial.printf("[%lu] [EBP] Could not find %s\n", millis(), tocNcxItem.c_str());
+  size_t tocSize;
+  if (!getItemSize(tocNcxItem, &tocSize)) {
+    Serial.printf("[%lu] [EBP] Could not get size of toc ncx\n", millis());
    return false;
  }

-  // Parse the Toc contents
-  tinyxml2::XMLDocument doc;
-  const auto result = doc.Parse(ncxData);
-  free(ncxData);
+  TocNcxParser ncxParser(contentBasePath, tocSize);

-  if (result != tinyxml2::XML_SUCCESS) {
-    Serial.printf("[%lu] [EBP] Error parsing toc %s\n", millis(), tinyxml2::XMLDocument::ErrorIDToName(result));
+  if (!ncxParser.setup()) {
+    Serial.printf("[%lu] [EBP] Could not setup toc ncx parser\n", millis());
    return false;
  }

-  const auto ncx = doc.FirstChildElement("ncx");
-  if (!ncx) {
-    Serial.printf("[%lu] [EBP] Could not find first child ncx in toc\n", millis());
+  if (!readItemContentsToStream(tocNcxItem, ncxParser, 1024)) {
+    Serial.printf("[%lu] [EBP] Could not read toc ncx stream\n", millis());
+    ncxParser.teardown();
    return false;
  }

-  const auto navMap = ncx->FirstChildElement("navMap");
-  if (!navMap) {
-    Serial.printf("[%lu] [EBP] Could not find navMap child in ncx\n", millis());
-    return false;
-  }
+  this->toc = std::move(ncxParser.toc);

-  recursivelyParseNavMap(navMap->FirstChildElement("navPoint"));
+  Serial.printf("[%lu] [EBP] Parsed %d TOC items\n", millis(), this->toc.size());
+
+  ncxParser.teardown();
  return true;
 }

-void Epub::recursivelyParseNavMap(tinyxml2::XMLElement* element) {
-  // Fills toc map
-  while (element) {
-    std::string navTitle = element->FirstChildElement("navLabel")->FirstChildElement("text")->FirstChild()->Value();
-    const auto content = element->FirstChildElement("content");
-    std::string href = contentBasePath + content->Attribute("src");
-    // split the href on the # to get the href and the anchor
-    const size_t pos = href.find('#');
-    std::string anchor;
-
-    if (pos != std::string::npos) {
-      anchor = href.substr(pos + 1);
-      href = href.substr(0, pos);
-    }
-
-    toc.emplace_back(navTitle, href, anchor, 0);
-
-    tinyxml2::XMLElement* nestedNavPoint = element->FirstChildElement("navPoint");
-    if (nestedNavPoint) {
-      recursivelyParseNavMap(nestedNavPoint);
-    }
-    element = element->NextSiblingElement("navPoint");
-  }
-}
-
 // load in the meta data for the epub file
 bool Epub::load() {
+  Serial.printf("[%lu] [EBP] Loading ePub: %s\n", millis(), filepath.c_str());
  ZipFile zip("/sd" + filepath);

-  std::string contentOpfFile;
-  if (!findContentOpfFile(zip, contentOpfFile)) {
-    Serial.printf("[%lu] [EBP] Could not open ePub\n", millis());
+  std::string contentOpfFilePath;
+  if (!findContentOpfFile(&contentOpfFilePath)) {
+    Serial.printf("[%lu] [EBP] Could not find content.opf in zip\n", millis());
    return false;
  }

-  contentBasePath = contentOpfFile.substr(0, contentOpfFile.find_last_of('/') + 1);
+  Serial.printf("[%lu] [EBP] Found content.opf at: %s\n", millis(), contentOpfFilePath.c_str());

-  if (!parseContentOpf(zip, contentOpfFile)) {
+  contentBasePath = contentOpfFilePath.substr(0, contentOpfFilePath.find_last_of('/') + 1);
+
+  if (!parseContentOpf(contentOpfFilePath)) {
+    Serial.printf("[%lu] [EBP] Could not parse content.opf\n", millis());
    return false;
  }

-  if (!parseTocNcxFile(zip)) {
+  if (!parseTocNcxFile()) {
+    Serial.printf("[%lu] [EBP] Could not parse toc\n", millis());
    return false;
  }

+  Serial.printf("[%lu] [EBP] Loaded ePub: %s\n", millis(), filepath.c_str());
+
  return true;
 }

-void Epub::clearCache() const { SD.rmdir(cachePath.c_str()); }
+bool Epub::clearCache() const {
+  if (!SD.exists(cachePath.c_str())) {
+    Serial.printf("[%lu] [EPB] Cache does not exist, no action needed\n", millis());
+    return true;
+  }
+
+  if (!FsHelpers::removeDir(cachePath.c_str())) {
+    Serial.printf("[%lu] [EPB] Failed to clear cache\n", millis());
+    return false;
+  }
+
+  Serial.printf("[%lu] [EPB] Cache cleared successfully\n", millis());
+  return true;
+}

 void Epub::setupCacheDir() const {
  if (SD.exists(cachePath.c_str())) {
@@ -329,6 +245,13 @@ bool Epub::readItemContentsToStream(const std::string& itemHref, Print& out, con
  return zip.readFileToStream(path.c_str(), out, chunkSize);
 }

+bool Epub::getItemSize(const std::string& itemHref, size_t* size) const {
+  const ZipFile zip("/sd" + filepath);
+  const std::string path = normalisePath(itemHref);
+
+  return zip.getInflatedFileSize(path.c_str(), size);
+}
+
 int Epub::getSpineItemsCount() const { return spine.size(); }

 std::string& Epub::getSpineItem(const int spineIndex) {
@@ -1,22 +1,13 @@
 #pragma once
 #include <Print.h>
-#include <tinyxml2.h>

 #include <string>
 #include <unordered_map>
 #include <vector>

-class ZipFile;
+#include "Epub/EpubTocEntry.h"

-class EpubTocEntry {
- public:
-  std::string title;
-  std::string href;
-  std::string anchor;
-  int level;
-  EpubTocEntry(std::string title, std::string href, std::string anchor, const int level)
-      : title(std::move(title)), href(std::move(href)), anchor(std::move(anchor)), level(level) {}
-};
+class ZipFile;

 class Epub {
  // the title read from the EPUB meta data
@@ -36,11 +27,9 @@ class Epub {
  // Uniq cache key based on filepath
  std::string cachePath;

-  // find the path for the content.opf file
-  static bool findContentOpfFile(const ZipFile& zip, std::string& contentOpfFile);
-  bool parseContentOpf(ZipFile& zip, std::string& content_opf_file);
-  bool parseTocNcxFile(const ZipFile& zip);
-  void recursivelyParseNavMap(tinyxml2::XMLElement* element);
+  bool findContentOpfFile(std::string* contentOpfFile) const;
+  bool parseContentOpf(const std::string& contentOpfFilePath);
+  bool parseTocNcxFile();

 public:
  explicit Epub(std::string filepath, const std::string& cacheDir) : filepath(std::move(filepath)) {
@@ -50,7 +39,7 @@ class Epub {
  ~Epub() = default;
  std::string& getBasePath() { return contentBasePath; }
  bool load();
-  void clearCache() const;
+  bool clearCache() const;
  void setupCacheDir() const;
  const std::string& getCachePath() const;
  const std::string& getPath() const;
@@ -59,6 +48,7 @@ class Epub {
  uint8_t* readItemContentsToBytes(const std::string& itemHref, size_t* size = nullptr,
                                   bool trailingNullByte = false) const;
  bool readItemContentsToStream(const std::string& itemHref, Print& out, size_t chunkSize) const;
+  bool getItemSize(const std::string& itemHref, size_t* size) const;
  std::string& getSpineItem(int spineIndex);
  int getSpineItemsCount() const;
  EpubTocEntry& getTocItem(int tocTndex);
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string>
+
+class EpubTocEntry {
+ public:
+  std::string title;
+  std::string href;
+  std::string anchor;
+  int level;
+  EpubTocEntry(std::string title, std::string href, std::string anchor, const int level)
+      : title(std::move(title)), href(std::move(href)), anchor(std::move(anchor)), level(level) {}
+};
@@ -0,0 +1,36 @@
+#include "FsHelpers.h"
+
+#include <SD.h>
+
+bool FsHelpers::removeDir(const char* path) {
+  // 1. Open the directory
+  File dir = SD.open(path);
+  if (!dir) {
+    return false;
+  }
+  if (!dir.isDirectory()) {
+    return false;
+  }
+
+  File file = dir.openNextFile();
+  while (file) {
+    String filePath = path;
+    if (!filePath.endsWith("/")) {
+      filePath += "/";
+    }
+    filePath += file.name();
+
+    if (file.isDirectory()) {
+      if (!removeDir(filePath.c_str())) {
+        return false;
+      }
+    } else {
+      if (!SD.remove(filePath.c_str())) {
+        return false;
+      }
+    }
+    file = dir.openNextFile();
+  }
+
+  return SD.rmdir(path);
+}
@@ -0,0 +1,6 @@
+#pragma once
+
+class FsHelpers {
+ public:
+  static bool removeDir(const char* path);
+};
@@ -3,7 +3,7 @@
 #include <HardwareSerial.h>
 #include <Serialization.h>

-constexpr uint8_t PAGE_FILE_VERSION = 1;
+constexpr uint8_t PAGE_FILE_VERSION = 3;

 void PageLine::render(GfxRenderer& renderer, const int fontId) { block->render(renderer, fontId, xPos, yPos); }

@@ -15,18 +15,18 @@ void PageLine::serialize(std::ostream& os) {
  block->serialize(os);
 }

-PageLine* PageLine::deserialize(std::istream& is) {
-  int32_t xPos;
-  int32_t yPos;
+std::unique_ptr<PageLine> PageLine::deserialize(std::istream& is) {
+  int16_t xPos;
+  int16_t yPos;
  serialization::readPod(is, xPos);
  serialization::readPod(is, yPos);

-  const auto tb = TextBlock::deserialize(is);
-  return new PageLine(tb, xPos, yPos);
+  auto tb = TextBlock::deserialize(is);
+  return std::unique_ptr<PageLine>(new PageLine(std::move(tb), xPos, yPos));
 }

 void Page::render(GfxRenderer& renderer, const int fontId) const {
-  for (const auto element : elements) {
+  for (auto& element : elements) {
    element->render(renderer, fontId);
  }
 }
@@ -37,14 +37,14 @@ void Page::serialize(std::ostream& os) const {
  const uint32_t count = elements.size();
  serialization::writePod(os, count);

-  for (auto* el : elements) {
+  for (const auto& el : elements) {
    // Only PageLine exists currently
    serialization::writePod(os, static_cast<uint8_t>(TAG_PageLine));
-    static_cast<PageLine*>(el)->serialize(os);
+    el->serialize(os);
  }
 }

-Page* Page::deserialize(std::istream& is) {
+std::unique_ptr<Page> Page::deserialize(std::istream& is) {
  uint8_t version;
  serialization::readPod(is, version);
  if (version != PAGE_FILE_VERSION) {
@@ -52,7 +52,7 @@ Page* Page::deserialize(std::istream& is) {
    return nullptr;
  }

-  auto* page = new Page();
+  auto page = std::unique_ptr<Page>(new Page());

  uint32_t count;
  serialization::readPod(is, count);
@@ -62,10 +62,11 @@ Page* Page::deserialize(std::istream& is) {
    serialization::readPod(is, tag);

    if (tag == TAG_PageLine) {
-      auto* pl = PageLine::deserialize(is);
-      page->elements.push_back(pl);
+      auto pl = PageLine::deserialize(is);
+      page->elements.push_back(std::move(pl));
    } else {
-      throw std::runtime_error("Unknown PageElement tag");
+      Serial.printf("[%lu] [PGE] Deserialization failed: Unknown tag %u\n", millis(), tag);
+      return nullptr;
    }
  }

@@ -1,4 +1,7 @@
 #pragma once
+#include <utility>
+#include <vector>
+
 #include "blocks/TextBlock.h"

 enum PageElementTag : uint8_t {
@@ -8,9 +11,9 @@ enum PageElementTag : uint8_t {
 // represents something that has been added to a page
 class PageElement {
 public:
-  int xPos;
-  int yPos;
-  explicit PageElement(const int xPos, const int yPos) : xPos(xPos), yPos(yPos) {}
+  int16_t xPos;
+  int16_t yPos;
+  explicit PageElement(const int16_t xPos, const int16_t yPos) : xPos(xPos), yPos(yPos) {}
  virtual ~PageElement() = default;
  virtual void render(GfxRenderer& renderer, int fontId) = 0;
  virtual void serialize(std::ostream& os) = 0;
@@ -18,27 +21,21 @@ class PageElement {

 // a line from a block element
 class PageLine final : public PageElement {
-  const TextBlock* block;
+  std::shared_ptr<TextBlock> block;

 public:
-  PageLine(const TextBlock* block, const int xPos, const int yPos) : PageElement(xPos, yPos), block(block) {}
-  ~PageLine() override { delete block; }
+  PageLine(std::shared_ptr<TextBlock> block, const int16_t xPos, const int16_t yPos)
+      : PageElement(xPos, yPos), block(std::move(block)) {}
  void render(GfxRenderer& renderer, int fontId) override;
  void serialize(std::ostream& os) override;
-  static PageLine* deserialize(std::istream& is);
+  static std::unique_ptr<PageLine> deserialize(std::istream& is);
 };

 class Page {
 public:
-  ~Page() {
-    for (const auto element : elements) {
-      delete element;
-    }
-  }
-
  // the list of block index and line numbers on this page
-  std::vector<PageElement*> elements;
+  std::vector<std::shared_ptr<PageElement>> elements;
  void render(GfxRenderer& renderer, int fontId) const;
  void serialize(std::ostream& os) const;
-  static Page* deserialize(std::istream& is);
+  static std::unique_ptr<Page> deserialize(std::istream& is);
 };
@@ -0,0 +1,164 @@
+#include "ParsedText.h"
+
+#include <GfxRenderer.h>
+
+#include <algorithm>
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <vector>
+
+constexpr int MAX_COST = std::numeric_limits<int>::max();
+
+void ParsedText::addWord(std::string word, const EpdFontStyle fontStyle) {
+  if (word.empty()) return;
+
+  words.push_back(std::move(word));
+  wordStyles.push_back(fontStyle);
+}
+
+// Consumes data to minimize memory usage
+void ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fontId, const int horizontalMargin,
+                                       const std::function<void(std::shared_ptr<TextBlock>)>& processLine) {
+  if (words.empty()) {
+    return;
+  }
+
+  const size_t totalWordCount = words.size();
+  const int pageWidth = renderer.getScreenWidth() - horizontalMargin;
+  const int spaceWidth = renderer.getSpaceWidth(fontId);
+
+  std::vector<uint16_t> wordWidths;
+  wordWidths.reserve(totalWordCount);
+
+  auto wordsIt = words.begin();
+  auto wordStylesIt = wordStyles.begin();
+
+  while (wordsIt != words.end()) {
+    wordWidths.push_back(renderer.getTextWidth(fontId, wordsIt->c_str(), *wordStylesIt));
+
+    std::advance(wordsIt, 1);
+    std::advance(wordStylesIt, 1);
+  }
+
+  // DP table to store the minimum badness (cost) of lines starting at index i
+  std::vector<int> dp(totalWordCount);
+  // 'ans[i]' stores the index 'j' of the *last word* in the optimal line starting at 'i'
+  std::vector<size_t> ans(totalWordCount);
+
+  // Base Case
+  dp[totalWordCount - 1] = 0;
+  ans[totalWordCount - 1] = totalWordCount - 1;
+
+  for (int i = totalWordCount - 2; i >= 0; --i) {
+    int currlen = -spaceWidth;
+    dp[i] = MAX_COST;
+
+    for (size_t j = i; j < totalWordCount; ++j) {
+      // Current line length: previous width + space + current word width
+      currlen += wordWidths[j] + spaceWidth;
+
+      if (currlen > pageWidth) {
+        break;
+      }
+
+      int cost;
+      if (j == totalWordCount - 1) {
+        cost = 0;  // Last line
+      } else {
+        const int remainingSpace = pageWidth - currlen;
+        // Use long long for the square to prevent overflow
+        const long long cost_ll = static_cast<long long>(remainingSpace) * remainingSpace + dp[j + 1];
+
+        if (cost_ll > MAX_COST) {
+          cost = MAX_COST;
+        } else {
+          cost = static_cast<int>(cost_ll);
+        }
+      }
+
+      if (cost < dp[i]) {
+        dp[i] = cost;
+        ans[i] = j;  // j is the index of the last word in this optimal line
+      }
+    }
+  }
+
+  // Stores the index of the word that starts the next line (last_word_index + 1)
+  std::vector<size_t> lineBreakIndices;
+  size_t currentWordIndex = 0;
+  constexpr size_t MAX_LINES = 1000;
+
+  while (currentWordIndex < totalWordCount) {
+    if (lineBreakIndices.size() >= MAX_LINES) {
+      break;
+    }
+
+    size_t nextBreakIndex = ans[currentWordIndex] + 1;
+    lineBreakIndices.push_back(nextBreakIndex);
+
+    currentWordIndex = nextBreakIndex;
+  }
+
+  // Initialize iterators for consumption
+  auto wordStartIt = words.begin();
+  auto wordStyleStartIt = wordStyles.begin();
+  size_t wordWidthIndex = 0;
+
+  size_t lastBreakAt = 0;
+  for (const size_t lineBreak : lineBreakIndices) {
+    const size_t lineWordCount = lineBreak - lastBreakAt;
+
+    // Calculate end iterators for the range to splice
+    auto wordEndIt = wordStartIt;
+    auto wordStyleEndIt = wordStyleStartIt;
+    std::advance(wordEndIt, lineWordCount);
+    std::advance(wordStyleEndIt, lineWordCount);
+
+    // Calculate total word width for this line
+    int lineWordWidthSum = 0;
+    for (size_t i = 0; i < lineWordCount; ++i) {
+      lineWordWidthSum += wordWidths[wordWidthIndex + i];
+    }
+
+    // Calculate spacing
+    const int spareSpace = pageWidth - lineWordWidthSum;
+    int spacing = spaceWidth;
+    const bool isLastLine = lineBreak == totalWordCount;
+
+    if (style == TextBlock::JUSTIFIED && !isLastLine && lineWordCount >= 2) {
+      spacing = spareSpace / (lineWordCount - 1);
+    }
+
+    // Calculate initial x position
+    uint16_t xpos = 0;
+    if (style == TextBlock::RIGHT_ALIGN) {
+      xpos = spareSpace - (lineWordCount - 1) * spaceWidth;
+    } else if (style == TextBlock::CENTER_ALIGN) {
+      xpos = (spareSpace - (lineWordCount - 1) * spaceWidth) / 2;
+    }
+
+    // Pre-calculate X positions for words
+    std::list<uint16_t> lineXPos;
+    for (size_t i = 0; i < lineWordCount; ++i) {
+      const uint16_t currentWordWidth = wordWidths[wordWidthIndex + i];
+      lineXPos.push_back(xpos);
+      xpos += currentWordWidth + spacing;
+    }
+
+    // *** CRITICAL STEP: CONSUME DATA USING SPLICE ***
+    std::list<std::string> lineWords;
+    lineWords.splice(lineWords.begin(), words, wordStartIt, wordEndIt);
+    std::list<EpdFontStyle> lineWordStyles;
+    lineWordStyles.splice(lineWordStyles.begin(), wordStyles, wordStyleStartIt, wordStyleEndIt);
+
+    processLine(
+        std::make_shared<TextBlock>(std::move(lineWords), std::move(lineXPos), std::move(lineWordStyles), style));
+
+    // Update pointers/indices for the next line
+    wordStartIt = wordEndIt;
+    wordStyleStartIt = wordStyleEndIt;
+    wordWidthIndex += lineWordCount;
+    lastBreakAt = lineBreak;
+  }
+}
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <EpdFontFamily.h>
+
+#include <cstdint>
+#include <functional>
+#include <list>
+#include <memory>
+#include <string>
+
+#include "blocks/TextBlock.h"
+
+class GfxRenderer;
+
+class ParsedText {
+  std::list<std::string> words;
+  std::list<EpdFontStyle> wordStyles;
+  TextBlock::BLOCK_STYLE style;
+
+ public:
+  explicit ParsedText(const TextBlock::BLOCK_STYLE style) : style(style) {}
+  ~ParsedText() = default;
+
+  void addWord(std::string word, EpdFontStyle fontStyle);
+  void setStyle(const TextBlock::BLOCK_STYLE style) { this->style = style; }
+  TextBlock::BLOCK_STYLE getStyle() const { return style; }
+  bool isEmpty() const { return words.empty(); }
+  void layoutAndExtractLines(const GfxRenderer& renderer, int fontId, int horizontalMargin,
+                             const std::function<void(std::shared_ptr<TextBlock>)>& processLine);
+};
@@ -1,17 +1,17 @@
 #include "Section.h"

-#include <GfxRenderer.h>
 #include <SD.h>
+#include <Serialization.h>

 #include <fstream>

-#include "EpubHtmlParserSlim.h"
+#include "FsHelpers.h"
 #include "Page.h"
-#include "Serialization.h"
+#include "parsers/ChapterHtmlSlimParser.h"

-constexpr uint8_t SECTION_FILE_VERSION = 3;
+constexpr uint8_t SECTION_FILE_VERSION = 4;

-void Section::onPageComplete(const Page* page) {
+void Section::onPageComplete(std::unique_ptr<Page> page) {
  const auto filePath = cachePath + "/page_" + std::to_string(pageCount) + ".bin";

  std::ofstream outputFile("/sd" + filePath);
@@ -21,7 +21,6 @@ void Section::onPageComplete(const Page* page) {
  Serial.printf("[%lu] [SCT] Page %d processed\n", millis(), pageCount);

  pageCount++;
-  delete page;
 }

 void Section::writeCacheMetadata(const int fontId, const float lineCompression, const int marginTop,
@@ -57,8 +56,8 @@ bool Section::loadCacheMetadata(const int fontId, const float lineCompression, c
    serialization::readPod(inputFile, version);
    if (version != SECTION_FILE_VERSION) {
      inputFile.close();
-      clearCache();
      Serial.printf("[%lu] [SCT] Deserialization failed: Unknown version %u\n", millis(), version);
+      clearCache();
      return false;
    }

@@ -74,8 +73,8 @@ bool Section::loadCacheMetadata(const int fontId, const float lineCompression, c
    if (fontId != fileFontId || lineCompression != fileLineCompression || marginTop != fileMarginTop ||
        marginRight != fileMarginRight || marginBottom != fileMarginBottom || marginLeft != fileMarginLeft) {
      inputFile.close();
-      clearCache();
      Serial.printf("[%lu] [SCT] Deserialization failed: Parameters do not match\n", millis());
+      clearCache();
      return false;
    }
  }
@@ -91,7 +90,21 @@ void Section::setupCacheDir() const {
  SD.mkdir(cachePath.c_str());
 }

-void Section::clearCache() const { SD.rmdir(cachePath.c_str()); }
+// Your updated class method (assuming you are using the 'SD' object, which is a wrapper for a specific filesystem)
+bool Section::clearCache() const {
+  if (!SD.exists(cachePath.c_str())) {
+    Serial.printf("[%lu] [SCT] Cache does not exist, no action needed\n", millis());
+    return true;
+  }
+
+  if (!FsHelpers::removeDir(cachePath.c_str())) {
+    Serial.printf("[%lu] [SCT] Failed to clear cache\n", millis());
+    return false;
+  }
+
+  Serial.printf("[%lu] [SCT] Cache cleared successfully\n", millis());
+  return true;
+}

 bool Section::persistPageDataToSD(const int fontId, const float lineCompression, const int marginTop,
                                  const int marginRight, const int marginBottom, const int marginLeft) {
@@ -114,8 +127,9 @@ bool Section::persistPageDataToSD(const int fontId, const float lineCompression,

  const auto sdTmpHtmlPath = "/sd" + tmpHtmlPath;

-  auto visitor = EpubHtmlParserSlim(sdTmpHtmlPath.c_str(), renderer, fontId, lineCompression, marginTop, marginRight,
-                                    marginBottom, marginLeft, [this](const Page* page) { this->onPageComplete(page); });
+  ChapterHtmlSlimParser visitor(sdTmpHtmlPath.c_str(), renderer, fontId, lineCompression, marginTop, marginRight,
+                                marginBottom, marginLeft,
+                                [this](std::unique_ptr<Page> page) { this->onPageComplete(std::move(page)); });
  success = visitor.parseAndBuildPages();

  SD.remove(tmpHtmlPath.c_str());
@@ -129,7 +143,7 @@ bool Section::persistPageDataToSD(const int fontId, const float lineCompression,
  return true;
 }

-Page* Section::loadPageFromSD() const {
+std::unique_ptr<Page> Section::loadPageFromSD() const {
  const auto filePath = "/sd" + cachePath + "/page_" + std::to_string(currentPage) + ".bin";
  if (!SD.exists(filePath.c_str() + 3)) {
    Serial.printf("[%lu] [SCT] Page file does not exist: %s\n", millis(), filePath.c_str());
@@ -137,7 +151,7 @@ Page* Section::loadPageFromSD() const {
  }

  std::ifstream inputFile(filePath);
-  Page* p = Page::deserialize(inputFile);
+  auto page = Page::deserialize(inputFile);
  inputFile.close();
-  return p;
+  return page;
 }
@@ -1,24 +1,26 @@
 #pragma once
+#include <memory>
+
 #include "Epub.h"

 class Page;
 class GfxRenderer;

 class Section {
-  Epub* epub;
+  std::shared_ptr<Epub> epub;
  const int spineIndex;
  GfxRenderer& renderer;
  std::string cachePath;

  void writeCacheMetadata(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
                          int marginLeft) const;
-  void onPageComplete(const Page* page);
+  void onPageComplete(std::unique_ptr<Page> page);

 public:
  int pageCount = 0;
  int currentPage = 0;

-  explicit Section(Epub* epub, const int spineIndex, GfxRenderer& renderer)
+  explicit Section(const std::shared_ptr<Epub>& epub, const int spineIndex, GfxRenderer& renderer)
      : epub(epub), spineIndex(spineIndex), renderer(renderer) {
    cachePath = epub->getCachePath() + "/" + std::to_string(spineIndex);
  }
@@ -26,8 +28,8 @@ class Section {
  bool loadCacheMetadata(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
                         int marginLeft);
  void setupCacheDir() const;
-  void clearCache() const;
+  bool clearCache() const;
  bool persistPageDataToSD(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
                           int marginLeft);
-  Page* loadPageFromSD() const;
+  std::unique_ptr<Page> loadPageFromSD() const;
 };
@@ -3,170 +3,17 @@
 #include <GfxRenderer.h>
 #include <Serialization.h>

-void TextBlock::addWord(const std::string& word, const bool is_bold, const bool is_italic) {
-  if (word.length() == 0) return;
-
-  words.push_back(word);
-  wordStyles.push_back((is_bold ? BOLD_SPAN : 0) | (is_italic ? ITALIC_SPAN : 0));
-}
-
-std::list<TextBlock*> TextBlock::splitIntoLines(const GfxRenderer& renderer, const int fontId,
-                                                const int horizontalMargin) {
-  const int totalWordCount = words.size();
-  const int pageWidth = GfxRenderer::getScreenWidth() - horizontalMargin;
-  const int spaceWidth = renderer.getSpaceWidth(fontId);
-
-  words.shrink_to_fit();
-  wordStyles.shrink_to_fit();
-  wordXpos.reserve(totalWordCount);
-
-  // measure each word
-  uint16_t wordWidths[totalWordCount];
-  for (int i = 0; i < totalWordCount; i++) {
-    // measure the word
-    EpdFontStyle fontStyle = REGULAR;
-    if (wordStyles[i] & BOLD_SPAN) {
-      if (wordStyles[i] & ITALIC_SPAN) {
-        fontStyle = BOLD_ITALIC;
-      } else {
-        fontStyle = BOLD;
-      }
-    } else if (wordStyles[i] & ITALIC_SPAN) {
-      fontStyle = ITALIC;
-    }
-    const int width = renderer.getTextWidth(fontId, words[i].c_str(), fontStyle);
-    wordWidths[i] = width;
-  }
-
-  // now apply the dynamic programming algorithm to find the best line breaks
-  // DP table in which dp[i] represents cost of line starting with word words[i]
-  int dp[totalWordCount];
-
-  // Array in which ans[i] store index of last word in line starting with word
-  // word[i]
-  size_t ans[totalWordCount];
-
-  // If only one word is present then only one line is required. Cost of last
-  // line is zero. Hence cost of this line is zero. Ending point is also n-1 as
-  // single word is present
-  dp[totalWordCount - 1] = 0;
-  ans[totalWordCount - 1] = totalWordCount - 1;
-
-  // Make each word first word of line by iterating over each index in arr.
-  for (int i = totalWordCount - 2; i >= 0; i--) {
-    int currlen = -1;
-    dp[i] = INT_MAX;
-
-    // Variable to store possible minimum cost of line.
-    int cost;
-
-    // Keep on adding words in current line by iterating from starting word upto
-    // last word in arr.
-    for (int j = i; j < totalWordCount; j++) {
-      // Update the width of the words in current line + the space between two
-      // words.
-      currlen += wordWidths[j] + spaceWidth;
-
-      // If we're bigger than the current pagewidth then we can't add more words
-      if (currlen > pageWidth) break;
-
-      // if we've run out of words then this is last line and the cost should be
-      // 0 Otherwise the cost is the sqaure of the left over space + the costs
-      // of all the previous lines
-      if (j == totalWordCount - 1)
-        cost = 0;
-      else
-        cost = (pageWidth - currlen) * (pageWidth - currlen) + dp[j + 1];
-
-      // Check if this arrangement gives minimum cost for line starting with
-      // word words[i].
-      if (cost < dp[i]) {
-        dp[i] = cost;
-        ans[i] = j;
-      }
-    }
-  }
-
-  // We can now iterate through the answer to find the line break positions
-  std::list<uint16_t> lineBreaks;
-  for (size_t i = 0; i < totalWordCount;) {
-    i = ans[i] + 1;
-    if (i > totalWordCount) {
-      break;
-    }
-    lineBreaks.push_back(i);
-    // Text too big, just exit
-    if (lineBreaks.size() > 1000) {
-      break;
-    }
-  }
-
-  std::list<TextBlock*> lines;
-
-  // With the line breaks calculated we can now position the words along the
-  // line
-  int startWord = 0;
-  for (const auto lineBreak : lineBreaks) {
-    const int lineWordCount = lineBreak - startWord;
-
-    int lineWordWidthSum = 0;
-    for (int i = startWord; i < lineBreak; i++) {
-      lineWordWidthSum += wordWidths[i];
-    }
-
-    // Calculate spacing between words
-    const uint16_t spareSpace = pageWidth - lineWordWidthSum;
-    uint16_t spacing = spaceWidth;
-    // evenly space words if using justified style, not the last line, and at
-    // least 2 words
-    if (style == JUSTIFIED && lineBreak != lineBreaks.back() && lineWordCount >= 2) {
-      spacing = spareSpace / (lineWordCount - 1);
-    }
-
-    uint16_t xpos = 0;
-    if (style == RIGHT_ALIGN) {
-      xpos = spareSpace - (lineWordCount - 1) * spaceWidth;
-    } else if (style == CENTER_ALIGN) {
-      xpos = (spareSpace - (lineWordCount - 1) * spaceWidth) / 2;
-    }
-
-    for (int i = startWord; i < lineBreak; i++) {
-      wordXpos[i] = xpos;
-      xpos += wordWidths[i] + spacing;
-    }
-
-    std::vector<std::string> lineWords;
-    std::vector<uint16_t> lineXPos;
-    std::vector<uint8_t> lineWordStyles;
-    lineWords.reserve(lineWordCount);
-    lineXPos.reserve(lineWordCount);
-    lineWordStyles.reserve(lineWordCount);
-
-    for (int i = startWord; i < lineBreak; i++) {
-      lineWords.push_back(words[i]);
-      lineXPos.push_back(wordXpos[i]);
-      lineWordStyles.push_back(wordStyles[i]);
-    }
-    const auto textLine = new TextBlock(lineWords, lineXPos, lineWordStyles, style);
-    lines.push_back(textLine);
-    startWord = lineBreak;
-  }
-
-  return lines;
-}
-
 void TextBlock::render(const GfxRenderer& renderer, const int fontId, const int x, const int y) const {
+  auto wordIt = words.begin();
+  auto wordStylesIt = wordStyles.begin();
+  auto wordXposIt = wordXpos.begin();
+
  for (int i = 0; i < words.size(); i++) {
-    // render the word
-    EpdFontStyle fontStyle = REGULAR;
-    if (wordStyles[i] & BOLD_SPAN && wordStyles[i] & ITALIC_SPAN) {
-      fontStyle = BOLD_ITALIC;
-    } else if (wordStyles[i] & BOLD_SPAN) {
-      fontStyle = BOLD;
-    } else if (wordStyles[i] & ITALIC_SPAN) {
-      fontStyle = ITALIC;
-    }
-    renderer.drawText(fontId, x + wordXpos[i], y, words[i].c_str(), true, fontStyle);
+    renderer.drawText(fontId, *wordXposIt + x, y, wordIt->c_str(), true, *wordStylesIt);
+
+    std::advance(wordIt, 1);
+    std::advance(wordStylesIt, 1);
+    std::advance(wordXposIt, 1);
  }
 }

@@ -190,11 +37,11 @@ void TextBlock::serialize(std::ostream& os) const {
  serialization::writePod(os, style);
 }

-TextBlock* TextBlock::deserialize(std::istream& is) {
+std::unique_ptr<TextBlock> TextBlock::deserialize(std::istream& is) {
  uint32_t wc, xc, sc;
-  std::vector<std::string> words;
-  std::vector<uint16_t> wordXpos;
-  std::vector<uint8_t> wordStyles;
+  std::list<std::string> words;
+  std::list<uint16_t> wordXpos;
+  std::list<EpdFontStyle> wordStyles;
  BLOCK_STYLE style;

  // words
@@ -215,5 +62,5 @@ TextBlock* TextBlock::deserialize(std::istream& is) {
  // style
  serialization::readPod(is, style);

-  return new TextBlock(words, wordXpos, wordStyles, style);
+  return std::unique_ptr<TextBlock>(new TextBlock(std::move(words), std::move(wordXpos), std::move(wordStyles), style));
 }
@@ -1,50 +1,40 @@
 #pragma once
+#include <EpdFontFamily.h>
+
 #include <list>
+#include <memory>
 #include <string>
-#include <vector>

 #include "Block.h"

-enum SPAN_STYLE : uint8_t {
-  BOLD_SPAN = 1,
-  ITALIC_SPAN = 2,
-};
-
-enum BLOCK_STYLE : uint8_t {
-  JUSTIFIED = 0,
-  LEFT_ALIGN = 1,
-  CENTER_ALIGN = 2,
-  RIGHT_ALIGN = 3,
-};
-
 // represents a block of words in the html document
 class TextBlock final : public Block {
-  // pointer to each word
-  std::vector<std::string> words;
-  // x position of each word
-  std::vector<uint16_t> wordXpos;
-  // the styles of each word
-  std::vector<uint8_t> wordStyles;
+ public:
+  enum BLOCK_STYLE : uint8_t {
+    JUSTIFIED = 0,
+    LEFT_ALIGN = 1,
+    CENTER_ALIGN = 2,
+    RIGHT_ALIGN = 3,
+  };

-  // the style of the block - left, center, right aligned
+ private:
+  std::list<std::string> words;
+  std::list<uint16_t> wordXpos;
+  std::list<EpdFontStyle> wordStyles;
  BLOCK_STYLE style;

 public:
-  explicit TextBlock(const BLOCK_STYLE style) : style(style) {}
-  explicit TextBlock(const std::vector<std::string>& words, const std::vector<uint16_t>& word_xpos,
-                     // the styles of each word
-                     const std::vector<uint8_t>& word_styles, const BLOCK_STYLE style)
-      : words(words), wordXpos(word_xpos), wordStyles(word_styles), style(style) {}
+  explicit TextBlock(std::list<std::string> words, std::list<uint16_t> word_xpos, std::list<EpdFontStyle> word_styles,
+                     const BLOCK_STYLE style)
+      : words(std::move(words)), wordXpos(std::move(word_xpos)), wordStyles(std::move(word_styles)), style(style) {}
  ~TextBlock() override = default;
-  void addWord(const std::string& word, bool is_bold, bool is_italic);
  void setStyle(const BLOCK_STYLE style) { this->style = style; }
  BLOCK_STYLE getStyle() const { return style; }
  bool isEmpty() override { return words.empty(); }
  void layout(GfxRenderer& renderer) override {};
  // given a renderer works out where to break the words into lines
-  std::list<TextBlock*> splitIntoLines(const GfxRenderer& renderer, int fontId, int horizontalMargin);
  void render(const GfxRenderer& renderer, int fontId, int x, int y) const;
  BlockType getType() override { return TEXT_BLOCK; }
  void serialize(std::ostream& os) const;
-  static TextBlock* deserialize(std::istream& is);
+  static std::unique_ptr<TextBlock> deserialize(std::istream& is);
 };
@@ -1,11 +1,11 @@
-#include "EpubHtmlParserSlim.h"
+#include "ChapterHtmlSlimParser.h"

 #include <GfxRenderer.h>
 #include <HardwareSerial.h>
 #include <expat.h>

-#include "Page.h"
-#include "htmlEntities.h"
+#include "../Page.h"
+#include "../htmlEntities.h"

 const char* HEADER_TAGS[] = {"h1", "h2", "h3", "h4", "h5", "h6"};
 constexpr int NUM_HEADER_TAGS = sizeof(HEADER_TAGS) / sizeof(HEADER_TAGS[0]);
@@ -38,7 +38,7 @@ bool matches(const char* tag_name, const char* possible_tags[], const int possib
 }

 // start a new text block if needed
-void EpubHtmlParserSlim::startNewTextBlock(const BLOCK_STYLE style) {
+void ChapterHtmlSlimParser::startNewTextBlock(const TextBlock::BLOCK_STYLE style) {
  if (currentTextBlock) {
    // already have a text block running and it is empty - just reuse it
    if (currentTextBlock->isEmpty()) {
@@ -46,15 +46,13 @@ void EpubHtmlParserSlim::startNewTextBlock(const BLOCK_STYLE style) {
      return;
    }

-    currentTextBlock->finish();
    makePages();
-    delete currentTextBlock;
  }
-  currentTextBlock = new TextBlock(style);
+  currentTextBlock.reset(new ParsedText(style));
 }

-void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
-  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
+void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);
  (void)atts;

  // Middle of skip
@@ -64,23 +62,7 @@ void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* na
  }

  if (matches(name, IMAGE_TAGS, NUM_IMAGE_TAGS)) {
-    // const char* src = element.Attribute("src");
-    // if (src) {
-    //   // don't leave an empty text block in the list
-    //   // const BLOCK_STYLE style = currentTextBlock->get_style();
-    //   if (currentTextBlock->isEmpty()) {
-    //     delete currentTextBlock;
-    //     currentTextBlock = nullptr;
-    //   }
-    //   // TODO: Fix this
-    //   // blocks.push_back(new ImageBlock(m_base_path + src));
-    //   // start a new text block - with the same style as before
-    //   // startNewTextBlock(style);
-    // } else {
-    //   // ESP_LOGE(TAG, "Could not find src attribute");
-    // }
-
-    // start skip
+    // TODO: Start processing image tags
    self->skipUntilDepth = self->depth;
    self->depth += 1;
    return;
@@ -94,13 +76,13 @@ void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* na
  }

  if (matches(name, HEADER_TAGS, NUM_HEADER_TAGS)) {
-    self->startNewTextBlock(CENTER_ALIGN);
+    self->startNewTextBlock(TextBlock::CENTER_ALIGN);
    self->boldUntilDepth = min(self->boldUntilDepth, self->depth);
  } else if (matches(name, BLOCK_TAGS, NUM_BLOCK_TAGS)) {
    if (strcmp(name, "br") == 0) {
      self->startNewTextBlock(self->currentTextBlock->getStyle());
    } else {
-      self->startNewTextBlock(JUSTIFIED);
+      self->startNewTextBlock(TextBlock::JUSTIFIED);
    }
  } else if (matches(name, BOLD_TAGS, NUM_BOLD_TAGS)) {
    self->boldUntilDepth = min(self->boldUntilDepth, self->depth);
@@ -111,21 +93,29 @@ void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* na
  self->depth += 1;
 }

-void XMLCALL EpubHtmlParserSlim::characterData(void* userData, const XML_Char* s, const int len) {
-  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
+void XMLCALL ChapterHtmlSlimParser::characterData(void* userData, const XML_Char* s, const int len) {
+  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);

  // Middle of skip
  if (self->skipUntilDepth < self->depth) {
    return;
  }

+  EpdFontStyle fontStyle = REGULAR;
+  if (self->boldUntilDepth < self->depth && self->italicUntilDepth < self->depth) {
+    fontStyle = BOLD_ITALIC;
+  } else if (self->boldUntilDepth < self->depth) {
+    fontStyle = BOLD;
+  } else if (self->italicUntilDepth < self->depth) {
+    fontStyle = ITALIC;
+  }
+
  for (int i = 0; i < len; i++) {
    if (isWhitespace(s[i])) {
      // Currently looking at whitespace, if there's anything in the partWordBuffer, flush it
      if (self->partWordBufferIndex > 0) {
        self->partWordBuffer[self->partWordBufferIndex] = '\0';
-        self->currentTextBlock->addWord(replaceHtmlEntities(self->partWordBuffer), self->boldUntilDepth < self->depth,
-                                        self->italicUntilDepth < self->depth);
+        self->currentTextBlock->addWord(std::move(replaceHtmlEntities(self->partWordBuffer)), fontStyle);
        self->partWordBufferIndex = 0;
      }
      // Skip the whitespace char
@@ -135,8 +125,7 @@ void XMLCALL EpubHtmlParserSlim::characterData(void* userData, const XML_Char* s
    // If we're about to run out of space, then cut the word off and start a new one
    if (self->partWordBufferIndex >= MAX_WORD_SIZE) {
      self->partWordBuffer[self->partWordBufferIndex] = '\0';
-      self->currentTextBlock->addWord(replaceHtmlEntities(self->partWordBuffer), self->boldUntilDepth < self->depth,
-                                      self->italicUntilDepth < self->depth);
+      self->currentTextBlock->addWord(std::move(replaceHtmlEntities(self->partWordBuffer)), fontStyle);
      self->partWordBufferIndex = 0;
    }

@@ -144,8 +133,8 @@ void XMLCALL EpubHtmlParserSlim::characterData(void* userData, const XML_Char* s
  }
 }

-void XMLCALL EpubHtmlParserSlim::endElement(void* userData, const XML_Char* name) {
-  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
+void XMLCALL ChapterHtmlSlimParser::endElement(void* userData, const XML_Char* name) {
+  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);
  (void)name;

  if (self->partWordBufferIndex > 0) {
@@ -158,9 +147,17 @@ void XMLCALL EpubHtmlParserSlim::endElement(void* userData, const XML_Char* name
        matches(name, BOLD_TAGS, NUM_BOLD_TAGS) || matches(name, ITALIC_TAGS, NUM_ITALIC_TAGS) || self->depth == 1;

    if (shouldBreakText) {
+      EpdFontStyle fontStyle = REGULAR;
+      if (self->boldUntilDepth < self->depth && self->italicUntilDepth < self->depth) {
+        fontStyle = BOLD_ITALIC;
+      } else if (self->boldUntilDepth < self->depth) {
+        fontStyle = BOLD;
+      } else if (self->italicUntilDepth < self->depth) {
+        fontStyle = ITALIC;
+      }
+
      self->partWordBuffer[self->partWordBufferIndex] = '\0';
-      self->currentTextBlock->addWord(replaceHtmlEntities(self->partWordBuffer), self->boldUntilDepth < self->depth,
-                                      self->italicUntilDepth < self->depth);
+      self->currentTextBlock->addWord(std::move(replaceHtmlEntities(self->partWordBuffer)), fontStyle);
      self->partWordBufferIndex = 0;
    }
  }
@@ -183,8 +180,8 @@ void XMLCALL EpubHtmlParserSlim::endElement(void* userData, const XML_Char* name
  }
 }

-bool EpubHtmlParserSlim::parseAndBuildPages() {
-  startNewTextBlock(JUSTIFIED);
+bool ChapterHtmlSlimParser::parseAndBuildPages() {
+  startNewTextBlock(TextBlock::JUSTIFIED);

  const XML_Parser parser = XML_ParserCreate(nullptr);
  int done;
@@ -240,56 +237,43 @@ bool EpubHtmlParserSlim::parseAndBuildPages() {
  // Process last page if there is still text
  if (currentTextBlock) {
    makePages();
-    completePageFn(currentPage);
-    currentPage = nullptr;
-    delete currentTextBlock;
-    currentTextBlock = nullptr;
+    completePageFn(std::move(currentPage));
+    currentPage.reset();
+    currentTextBlock.reset();
  }

  return true;
 }

-void EpubHtmlParserSlim::makePages() {
+void ChapterHtmlSlimParser::addLineToPage(std::shared_ptr<TextBlock> line) {
+  const int lineHeight = renderer.getLineHeight(fontId) * lineCompression;
+  const int pageHeight = GfxRenderer::getScreenHeight() - marginTop - marginBottom;
+
+  if (currentPageNextY + lineHeight > pageHeight) {
+    completePageFn(std::move(currentPage));
+    currentPage.reset(new Page());
+    currentPageNextY = marginTop;
+  }
+
+  currentPage->elements.push_back(std::make_shared<PageLine>(line, marginLeft, currentPageNextY));
+  currentPageNextY += lineHeight;
+}
+
+void ChapterHtmlSlimParser::makePages() {
  if (!currentTextBlock) {
    Serial.printf("[%lu] [EHP] !! No text block to make pages for !!\n", millis());
    return;
  }

  if (!currentPage) {
-    currentPage = new Page();
+    currentPage.reset(new Page());
    currentPageNextY = marginTop;
  }

  const int lineHeight = renderer.getLineHeight(fontId) * lineCompression;
-  const int pageHeight = GfxRenderer::getScreenHeight() - marginTop - marginBottom;
-
-  // Long running task, make sure to let other things happen
-  vTaskDelay(1);
-
-  if (currentTextBlock->getType() == TEXT_BLOCK) {
-    const auto lines = currentTextBlock->splitIntoLines(renderer, fontId, marginLeft + marginRight);
-
-    for (const auto line : lines) {
-      if (currentPageNextY + lineHeight > pageHeight) {
-        completePageFn(currentPage);
-        currentPage = new Page();
-        currentPageNextY = marginTop;
-      }
-
-      currentPage->elements.push_back(new PageLine(line, marginLeft, currentPageNextY));
-      currentPageNextY += lineHeight;
-    }
-    // add some extra line between blocks
-    currentPageNextY += lineHeight / 2;
-  }
-  // TODO: Image block support
-  // if (block->getType() == BlockType::IMAGE_BLOCK) {
-  //   ImageBlock *imageBlock = (ImageBlock *)block;
-  //   if (y + imageBlock->height > page_height) {
-  //     pages.push_back(new Page());
-  //     y = 0;
-  //   }
-  //   pages.back()->elements.push_back(new PageImage(imageBlock, y));
-  //   y += imageBlock->height;
-  // }
+  currentTextBlock->layoutAndExtractLines(
+      renderer, fontId, marginLeft + marginRight,
+      [this](const std::shared_ptr<TextBlock>& textBlock) { addLineToPage(textBlock); });
+  // Extra paragrpah spacing
+  currentPageNextY += lineHeight / 2;
 }
@@ -4,18 +4,20 @@

 #include <climits>
 #include <functional>
+#include <memory>

-#include "blocks/TextBlock.h"
+#include "../ParsedText.h"
+#include "../blocks/TextBlock.h"

 class Page;
 class GfxRenderer;

 #define MAX_WORD_SIZE 200

-class EpubHtmlParserSlim {
+class ChapterHtmlSlimParser {
  const char* filepath;
  GfxRenderer& renderer;
-  std::function<void(Page*)> completePageFn;
+  std::function<void(std::unique_ptr<Page>)> completePageFn;
  int depth = 0;
  int skipUntilDepth = INT_MAX;
  int boldUntilDepth = INT_MAX;
@@ -24,9 +26,9 @@ class EpubHtmlParserSlim {
  // leave one char at end for null pointer
  char partWordBuffer[MAX_WORD_SIZE + 1] = {};
  int partWordBufferIndex = 0;
-  TextBlock* currentTextBlock = nullptr;
-  Page* currentPage = nullptr;
-  int currentPageNextY = 0;
+  std::unique_ptr<ParsedText> currentTextBlock = nullptr;
+  std::unique_ptr<Page> currentPage = nullptr;
+  int16_t currentPageNextY = 0;
  int fontId;
  float lineCompression;
  int marginTop;
@@ -34,7 +36,7 @@ class EpubHtmlParserSlim {
  int marginBottom;
  int marginLeft;

-  void startNewTextBlock(BLOCK_STYLE style);
+  void startNewTextBlock(TextBlock::BLOCK_STYLE style);
  void makePages();
  // XML callbacks
  static void XMLCALL startElement(void* userData, const XML_Char* name, const XML_Char** atts);
@@ -42,10 +44,10 @@ class EpubHtmlParserSlim {
  static void XMLCALL endElement(void* userData, const XML_Char* name);

 public:
-  explicit EpubHtmlParserSlim(const char* filepath, GfxRenderer& renderer, const int fontId,
-                              const float lineCompression, const int marginTop, const int marginRight,
-                              const int marginBottom, const int marginLeft,
-                              const std::function<void(Page*)>& completePageFn)
+  explicit ChapterHtmlSlimParser(const char* filepath, GfxRenderer& renderer, const int fontId,
+                                 const float lineCompression, const int marginTop, const int marginRight,
+                                 const int marginBottom, const int marginLeft,
+                                 const std::function<void(std::unique_ptr<Page>)>& completePageFn)
      : filepath(filepath),
        renderer(renderer),
        fontId(fontId),
@@ -55,6 +57,7 @@ class EpubHtmlParserSlim {
        marginBottom(marginBottom),
        marginLeft(marginLeft),
        completePageFn(completePageFn) {}
-  ~EpubHtmlParserSlim() = default;
+  ~ChapterHtmlSlimParser() = default;
  bool parseAndBuildPages();
+  void addLineToPage(std::shared_ptr<TextBlock> line);
 };
@@ -0,0 +1,96 @@
+#include "ContainerParser.h"
+
+#include <HardwareSerial.h>
+
+bool ContainerParser::setup() {
+  parser = XML_ParserCreate(nullptr);
+  if (!parser) {
+    Serial.printf("[%lu] [CTR] Couldn't allocate memory for parser\n", millis());
+    return false;
+  }
+
+  XML_SetUserData(parser, this);
+  XML_SetElementHandler(parser, startElement, endElement);
+  return true;
+}
+
+bool ContainerParser::teardown() {
+  if (parser) {
+    XML_ParserFree(parser);
+    parser = nullptr;
+  }
+  return true;
+}
+
+size_t ContainerParser::write(const uint8_t data) { return write(&data, 1); }
+
+size_t ContainerParser::write(const uint8_t* buffer, const size_t size) {
+  if (!parser) return 0;
+
+  const uint8_t* currentBufferPos = buffer;
+  auto remainingInBuffer = size;
+
+  while (remainingInBuffer > 0) {
+    void* const buf = XML_GetBuffer(parser, 1024);
+    if (!buf) {
+      Serial.printf("[%lu] [CTR] Couldn't allocate buffer\n", millis());
+      return 0;
+    }
+
+    const auto toRead = remainingInBuffer < 1024 ? remainingInBuffer : 1024;
+    memcpy(buf, currentBufferPos, toRead);
+
+    if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
+      Serial.printf("[%lu] [CTR] Parse error: %s\n", millis(), XML_ErrorString(XML_GetErrorCode(parser)));
+      return 0;
+    }
+
+    currentBufferPos += toRead;
+    remainingInBuffer -= toRead;
+    remainingSize -= toRead;
+  }
+  return size;
+}
+
+void XMLCALL ContainerParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+  auto* self = static_cast<ContainerParser*>(userData);
+
+  // Simple state tracking to ensure we are looking at the valid schema structure
+  if (self->state == START && strcmp(name, "container") == 0) {
+    self->state = IN_CONTAINER;
+    return;
+  }
+
+  if (self->state == IN_CONTAINER && strcmp(name, "rootfiles") == 0) {
+    self->state = IN_ROOTFILES;
+    return;
+  }
+
+  if (self->state == IN_ROOTFILES && strcmp(name, "rootfile") == 0) {
+    const char* mediaType = nullptr;
+    const char* path = nullptr;
+
+    for (int i = 0; atts[i]; i += 2) {
+      if (strcmp(atts[i], "media-type") == 0) {
+        mediaType = atts[i + 1];
+      } else if (strcmp(atts[i], "full-path") == 0) {
+        path = atts[i + 1];
+      }
+    }
+
+    // Check if this is the standard OEBPS package
+    if (mediaType && path && strcmp(mediaType, "application/oebps-package+xml") == 0) {
+      self->fullPath = path;
+    }
+  }
+}
+
+void XMLCALL ContainerParser::endElement(void* userData, const XML_Char* name) {
+  auto* self = static_cast<ContainerParser*>(userData);
+
+  if (self->state == IN_ROOTFILES && strcmp(name, "rootfiles") == 0) {
+    self->state = IN_CONTAINER;
+  } else if (self->state == IN_CONTAINER && strcmp(name, "container") == 0) {
+    self->state = START;
+  }
+}
@@ -0,0 +1,32 @@
+#pragma once
+#include <Print.h>
+
+#include <string>
+
+#include "expat.h"
+
+class ContainerParser final : public Print {
+  enum ParserState {
+    START,
+    IN_CONTAINER,
+    IN_ROOTFILES,
+  };
+
+  size_t remainingSize;
+  XML_Parser parser = nullptr;
+  ParserState state = START;
+
+  static void startElement(void* userData, const XML_Char* name, const XML_Char** atts);
+  static void endElement(void* userData, const XML_Char* name);
+
+ public:
+  std::string fullPath;
+
+  explicit ContainerParser(const size_t xmlSize) : remainingSize(xmlSize) {}
+
+  bool setup();
+  bool teardown();
+
+  size_t write(uint8_t) override;
+  size_t write(const uint8_t* buffer, size_t size) override;
+};
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dave Allie	5a7381a0eb	Cut release 0.5.0	2025-12-13 20:16:12 +11:00
Dave Allie	f69fc90b5c	Show end of book screen when navigating past last page	2025-12-13 20:10:38 +11:00
Dave Allie	5bae283838	Process lines into pages as they are built	2025-12-13 20:10:16 +11:00
Dave Allie	c7a32fe41f	Remove tinyxml2 dependency replace with expat parsers (#9 )	2025-12-13 19:36:01 +11:00
Dave Allie	d450f362d1	Cut release 0.4.0	2025-12-13 17:15:06 +11:00
Dave Allie	6ddcf9b592	Show clearer indexing string	2025-12-13 16:02:27 +11:00
Dave Allie	492c6fd23e	Bump page file version	2025-12-13 00:42:17 +11:00
Dave Allie	7c852cf7d1	Swap out babyblue font for pixelarial14	2025-12-13 00:16:10 +11:00
Dave Allie	69f357998e	Move to smart pointers and split out ParsedText class (#6 ) * Move to smart pointers and split out ParsedText class * Cleanup ParsedText * Fix clearCache functions and clear section cache if page load fails * Bump Page and Section file versions * Combine removeDir implementations in Epub * Adjust screen margins	2025-12-12 22:13:34 +11:00
Dave Allie	09f68a3d03	Restructure readme	2025-12-09 00:07:38 +11:00
Dave Allie	7ec7efcb47	Add section in readme on flashing via xteink.dve.al	2025-12-09 00:04:55 +11:00