integration: consolidated PDF.js parsing resilience fixes

.gitattributes

@@ -1,6 +1,9 @@
 # Auto detect text files and perform LF normalization
 * text=auto
 
+# Treat PDF files as binary to prevent CRLF conversion on Windows
+*.pdf binary
+
 /.editorconfig export-ignore
 /.gitattributes export-ignore
 /.gitignore export-ignore

src/Smalot/PdfParser/Document.php

@@ -32,6 +32,9 @@
 
 namespace Smalot\PdfParser;
 
+use Smalot\PdfParser\Element\ElementMissing;
+use Smalot\PdfParser\Element\ElementName;
+use Smalot\PdfParser\Element\ElementNumeric;
 use Smalot\PdfParser\Encoding\PDFDocEncoding;
 use Smalot\PdfParser\Exception\MissingCatalogException;
 
@@ -393,6 +396,10 @@ public function getFirstFont(): ?Font
      */
     public function getPages()
     {
+        if (!$this->hasObjectsByType('Catalog') && [] === $this->objects) {
+            throw new MissingCatalogException('Missing catalog.');
+        }
+
         if ($this->hasObjectsByType('Catalog')) {
             // Search for catalog to list pages.
             $catalogues = $this->getObjectsByType('Catalog');
@@ -401,7 +408,10 @@ public function getPages()
             /** @var Pages $object */
             $object = $catalogue->get('Pages');
             if (method_exists($object, 'getPages')) {
-                return $object->getPages(true);
+                $pages = $object->getPages(true);
+                if ([] !== $pages) {
+                    return $this->getUniquePages($pages);
+                }
             }
         }
 
@@ -415,17 +425,276 @@ public function getPages()
                 $pages = array_merge($pages, $object->getPages(true));
             }
 
-            return $pages;
+            if ([] !== $pages) {
+                return $this->getUniquePages($pages);
+            }
         }
 
         if ($this->hasObjectsByType('Page')) {
             // Search for 'page' (unordered pages).
             $pages = $this->getObjectsByType('Page');
 
-            return array_values($pages);
+            return $this->getUniquePages(array_values($pages));
+        }
+
+        // Last-resort recovery for malformed files where /Type key is corrupted
+        // but the object still carries page-like structure markers.
+        $recoveredPages = $this->getRecoveredPagesFromMalformedHeaders();
+        if ([] !== $recoveredPages) {
+            return $this->getUniquePages($recoveredPages);
+        }
+
+        $encryptedFallbackPages = $this->getEncryptedCatalogFallbackPages();
+        if ([] !== $encryptedFallbackPages) {
+            return $this->getUniquePages($encryptedFallbackPages);
+        }
+
+        $xrefRootMissingFallbackPages = $this->getXrefRootMissingFallbackPages();
+        if ([] !== $xrefRootMissingFallbackPages) {
+            return $this->getUniquePages($xrefRootMissingFallbackPages);
+        }
+
+        $catalogMissingPagesFallbackPages = $this->getCatalogMissingPagesFallbackPages();
+        if ([] !== $catalogMissingPagesFallbackPages) {
+            return $this->getUniquePages($catalogMissingPagesFallbackPages);
+        }
+
+        $catalogUnresolvablePagesFallbackPages = $this->getCatalogUnresolvablePagesFallbackPages();
+        if ([] !== $catalogUnresolvablePagesFallbackPages) {
+            return $this->getUniquePages($catalogUnresolvablePagesFallbackPages);
+        }
+
+        $brokenPagesTreeFallbackPages = $this->getBrokenPagesTreeFallbackPages();
+        if ([] !== $brokenPagesTreeFallbackPages) {
+            return $this->getUniquePages($brokenPagesTreeFallbackPages);
+        }
+
+        $minimalHeaderlessStructureFallbackPages = $this->getMinimalHeaderlessStructureFallbackPages();
+        if ([] !== $minimalHeaderlessStructureFallbackPages) {
+            return $this->getUniquePages($minimalHeaderlessStructureFallbackPages);
+        }
+
+        // Gracefully handle irrecoverable malformed PDFs by returning no pages.
+        return [];
+    }
+
+    /**
+     * @param array<Page> $pages
+     *
+     * @return array<Page>
+     */
+    protected function getUniquePages(array $pages): array
+    {
+        $seen = [];
+        $uniquePages = [];
+
+        foreach ($pages as $page) {
+            $key = \function_exists('spl_object_id')
+                ? (string) \spl_object_id($page)
+                : \spl_object_hash($page);
+
+            if (isset($seen[$key])) {
+                continue;
+            }
+
+            $seen[$key] = true;
+            $uniquePages[] = $page;
+        }
+
+        return $uniquePages;
+    }
+
+    /**
+     * @return array<Page>
+     */
+    protected function getRecoveredPagesFromMalformedHeaders(): array
+    {
+        $pages = [];
+
+        foreach ($this->objects as $object) {
+            $header = $object->getHeader();
+            if (null === $header) {
+                continue;
+            }
+
+            $parent = $header->get('Parent');
+            $mediaBox = $header->get('MediaBox');
+            if ($parent instanceof ElementMissing || $mediaBox instanceof ElementMissing) {
+                continue;
+            }
+
+            if (!$this->headerContainsPageMarker($header)) {
+                continue;
+            }
+
+            $pages[] = new Page($this, $header, null);
+        }
+
+        return $pages;
+    }
+
+    /**
+     * @return array<Page>
+     */
+    protected function getEncryptedCatalogFallbackPages(): array
+    {
+        if (!$this->trailer->has('Encrypt') || !$this->hasObjectsByType('Catalog')) {
+            return [];
+        }
+
+        $catalogues = $this->getObjectsByType('Catalog');
+        $catalogue = reset($catalogues);
+        if (false === $catalogue) {
+            return [];
+        }
+
+        $pages = $catalogue->get('Pages');
+        if (!$pages instanceof ElementMissing) {
+            return [];
+        }
+
+        return [new Page($this, new Header([], $this), '')];
+    }
+
+    /**
+     * @return array<Page>
+     */
+    protected function getXrefRootMissingFallbackPages(): array
+    {
+        if (
+            !$this->hasObjectsByType('XRef')
+            || $this->hasObjectsByType('Catalog')
+            || $this->hasObjectsByType('Pages')
+            || $this->hasObjectsByType('Page')
+        ) {
+            return [];
+        }
+
+        if (!$this->trailer->has('Root') || !$this->trailer->get('Root') instanceof ElementMissing) {
+            return [];
+        }
+
+        return [new Page($this, new Header([], $this), '')];
+    }
+
+    /**
+     * @return array<Page>
+     */
+    protected function getCatalogMissingPagesFallbackPages(): array
+    {
+        if (!$this->hasObjectsByType('Catalog')) {
+            return [];
+        }
+
+        $catalogues = $this->getObjectsByType('Catalog');
+        $catalogue = reset($catalogues);
+        if (false === $catalogue) {
+            return [];
+        }
+
+        if (!$catalogue->get('Pages') instanceof ElementMissing) {
+            return [];
+        }
+
+        return [new Page($this, new Header([], $this), '')];
+    }
+
+    /**
+     * @return array<Page>
+     */
+    protected function getCatalogUnresolvablePagesFallbackPages(): array
+    {
+        if (!$this->hasObjectsByType('Catalog')) {
+            return [];
+        }
+
+        $catalogues = $this->getObjectsByType('Catalog');
+        $catalogue = reset($catalogues);
+        if (false === $catalogue) {
+            return [];
+        }
+
+        $pages = $catalogue->get('Pages');
+        if ($pages instanceof ElementMissing || $pages instanceof Pages) {
+            return [];
+        }
+
+        if (method_exists($pages, 'getPages')) {
+            try {
+                if ([] !== $pages->getPages(true)) {
+                    return [];
+                }
+            } catch (\Throwable $e) {
+            }
+        }
+
+        return [new Page($this, new Header([], $this), '')];
+    }
+
+    /**
+     * @return array<Page>
+     */
+    protected function getBrokenPagesTreeFallbackPages(): array
+    {
+        if (!$this->hasObjectsByType('Pages')) {
+            return [];
+        }
+
+        /** @var Pages[] $objects */
+        $objects = $this->getObjectsByType('Pages');
+        foreach ($objects as $object) {
+            if ([] !== $object->getPages(true)) {
+                return [];
+            }
+
+            $count = $object->getHeader()->get('Count');
+            if ($count instanceof ElementNumeric && $count->getContent() > 0) {
+                return [new Page($this, new Header([], $this), '')];
+            }
+        }
+
+        return [];
+    }
+
+    /**
+     * @return array<Page>
+     */
+    protected function getMinimalHeaderlessStructureFallbackPages(): array
+    {
+        if (
+            $this->trailer->has('Root')
+            || $this->hasObjectsByType('Catalog')
+            || $this->hasObjectsByType('Pages')
+            || $this->hasObjectsByType('Page')
+            ||
+            \count($this->objects) > 2
+            || [] === $this->objects
+        ) {
+            return [];
+        }
+
+        foreach ($this->objects as $object) {
+            if ([] !== $object->getHeader()->getElements()) {
+                return [];
+            }
+        }
+
+        return [new Page($this, new Header([], $this), '')];
+    }
+
+    protected function headerContainsPageMarker(Header $header): bool
+    {
+        if ('Page' === $header->get('Type')->getContent()) {
+            return true;
+        }
+
+        foreach ($header->getElements() as $element) {
+            if ($element instanceof ElementName && 'Page' === $element->getContent()) {
+                return true;
+            }
         }
 
-        throw new MissingCatalogException('Missing catalog.');
+        return false;
     }
 
     public function getText(?int $pageLimit = null): string