@jackgreen2018/pdf-engine 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackgreen2018/pdf-engine",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "license": "MIT",
   "repository": {
     "type": "git",

package/pkg/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pdf_engine",
   "type": "module",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "files": [
     "pdf_engine_bg.wasm",
     "pdf_engine.js",

package/src/lib.rs

@@ -15,35 +15,67 @@ pub fn get_page_count(buffer: &[u8]) -> Result<u32, JsValue> {
     Ok(doc.get_pages().len().max(1) as u32)
 }
 
+/// Decode PDF hex strings (<HHHH...>) in content stream operators.
+fn decode_hex_strings(content: &str) -> String {
+    let mut result = String::new();
+    let bytes = content.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == b'<' {
+            let mut j = i + 1;
+            while j < bytes.len() && bytes[j] != b'>' {
+                j += 1;
+            }
+            if j > i + 1 && j < bytes.len() {
+                let hex = &content[i+1..j];
+                if hex.len() % 2 == 0 && hex.chars().all(|c| c.is_ascii_hexdigit()) {
+                    let mut buf = Vec::with_capacity(hex.len() / 2);
+                    for k in (0..hex.len()).step_by(2) {
+                        if let Ok(byte) = u8::from_str_radix(&hex[k..k+2], 16) {
+                            buf.push(byte);
+                        }
+                    }
+                    if let Ok(s) = String::from_utf8(buf) {
+                        result.push_str(&s);
+                    }
+                }
+            }
+            i = j + 1;
+        } else {
+            i += 1;
+        }
+    }
+    result
+}
+
+/// Extract text by iterating ALL objects and processing content streams.
+fn collect_page_text(doc: &Document) -> String {
+    let mut text = String::new();
+    for (_id, obj) in doc.objects.iter() {
+        let Object::Stream(ref stream) = obj else { continue };
+        let mut s = stream.clone();
+        let _ = s.decompress();
+        let content = String::from_utf8_lossy(&s.content);
+        // ponytail: only process streams that look like page content (have BT/ET text blocks)
+        if content.contains("BT") && content.contains("ET") {
+            text.push_str(&decode_hex_strings(&content));
+        }
+    }
+    text
+}
+
 #[wasm_bindgen]
 pub fn extract_text(buffer: &[u8]) -> Result<String, JsValue> {
     let doc = Document::load_mem(buffer)
         .map_err(|e| JsValue::from_str(&format!("PDF error: {}", e)))?;
 
-    let mut text = String::new();
-
-    for obj in doc.objects.values() {
-        if let Object::Dictionary(ref dict) = *obj {
-            let is_page = match dict.get(b"/Type") {
-                Ok(Object::String(s, _)) => s == b"Page",
-                _ => false,
-            };
-
-            if is_page {
-                match dict.get(b"/Contents") {
-                    Ok(Object::Stream(stream)) => {
-                        text.push_str(&String::from_utf8_lossy(&stream.content));
-                    },
-                    _ => {}
-                }
-            }
-        }
-    }
+    let text = collect_page_text(&doc);
 
     if text.is_empty() {
-        text = "No text extracted.".to_string();
+        Ok("No text extracted.".to_string())
+    } else {
+        Ok(text)
     }
-    Ok(text)
 }
 
 /// Remap all ObjectId references in `obj` using `id_map`.
@@ -109,11 +141,9 @@ fn walk_refs(obj: &Object, doc: &Document, visited: &mut BTreeMap<ObjectId, Obje
 
 /// Copy page at `page_obj_id` from `src` into `dst`, updating all internal references.
 fn copy_page_into(src: &Document, dst: &mut Document, page_obj_id: ObjectId) -> ObjectId {
-    // Collect all reachable objects from this page
     let mut to_copy: BTreeMap<ObjectId, Object> = BTreeMap::new();
     collect_reachable(page_obj_id, src, &mut to_copy);
 
-    // Assign new IDs in dst's address space
     let mut id_map: BTreeMap<ObjectId, ObjectId> = BTreeMap::new();
     let mut next_id = dst.max_id + 1;
 
@@ -156,12 +186,10 @@ pub fn merge(pdf_buffers: Array) -> Result<Uint8Array, JsValue> {
         let other = Document::load_mem(&buf.to_vec())
             .map_err(|e| JsValue::from_str(&format!("PDF load error: {}", e)))?;
 
-        // Pre-compute page count before any mutable borrow
         let page_count = doc.get_pages().len() as i64;
 
         for &page_obj_id in other.get_pages().values() {
             let new_page_id = copy_page_into(&other, &mut doc, page_obj_id);
-            // Append new page to the Pages catalog Kids array
             if let Ok(root_ref) = doc.trailer.get(b"Root").and_then(|r| r.as_reference()) {
                 if let Some(Object::Dictionary(ref mut root_dict)) = doc.objects.get_mut(&root_ref) {
                     if let Ok(pages_ref) = root_dict.get(b"Pages").and_then(|p| p.as_reference()) {
@@ -192,20 +220,16 @@ pub fn split(buffer: &[u8], pages: Array) -> Result<Array, JsValue> {
         .map_err(|e| JsValue::from_str(&format!("PDF error: {}", e)))?;
     let page_len = pages.length();
 
-    // get_pages returns BTreeMap<u32, ObjectId>
     let page_map: BTreeMap<u32, ObjectId> = doc.get_pages();
-
     let results = Array::new();
 
     for i in 0..page_len {
         let page_num = pages.get(i).as_f64().unwrap_or(0.0) as u32;
         let Some(&page_obj_id) = page_map.get(&page_num) else { continue };
 
-        // Build a new document containing just this page
         let mut new_doc = Document::with_version("1.5");
         let _ = copy_page_into(&doc, &mut new_doc, page_obj_id);
 
-        // Update the Pages catalog (first Pages dictionary in new_doc)
         if let Some((_, &pages_obj_id)) = new_doc.get_pages().iter().next() {
             let new_count = new_doc.get_pages().len() as i64;
             if let Some(Object::Dictionary(ref mut pages_dict)) = new_doc.objects.get_mut(&pages_obj_id) {