pdf-lite 1.6.2 → 1.6.4

package/dist/core/objects/pdf-dictionary.js

@@ -16,6 +16,9 @@ export class PdfDictionary extends PdfObject {
             }
         }
     }
+    keys() {
+        return Array.from(this.#entries.keys());
+    }
     get(key) {
         if (key instanceof PdfName) {
             return this.#entries.get(key);
@@ -131,6 +134,20 @@ export class PdfDictionary extends PdfObject {
             new PdfEndDictionaryToken(),
         ];
     }
+    /** Factory-style type conversion: constructs a new instance passing `this` as the first argument */
+    becomes(cls, ...args) {
+        if (this instanceof cls)
+            return this;
+        const donor = new cls(this, ...args);
+        Object.setPrototypeOf(this, cls.prototype);
+        for (const key of Object.getOwnPropertyNames(donor)) {
+            if (!Object.prototype.hasOwnProperty.call(this, key)) {
+                ;
+                this[key] = donor[key];
+            }
+        }
+        return this;
+    }
     copyFrom(other) {
         for (const [key, value] of other.#entries) {
             this.#entries.set(key, value);

package/dist/core/parser/incremental-parser.d.ts

@@ -70,8 +70,13 @@ export declare abstract class IncrementalParser<I, O> extends Parser<I, O> {
      */
     protected compact(): void;
     /**
-     * Override to customize when to compact the buffer
-     * By default, compacts when more than 1000 items have been consumed
+     * Override to customize when to compact the buffer.
+     * Compacts when more than 1000 items have been consumed AND we've consumed
+     * at least half the buffer. The second condition prevents O(n²) behaviour
+     * when a single large chunk is fed all at once: without it, compact() is
+     * called O(n/1000) times, each copying O(n) elements → O(n²) total.
+     * By requiring bufferIndex ≥ buffer.length/2 we ensure at most O(log n)
+     * compactions, for O(n) total copies.
      *
      * @returns boolean indicating whether to compact the buffer
      */

package/dist/core/parser/incremental-parser.js

@@ -139,13 +139,19 @@ export class IncrementalParser extends Parser {
         }
     }
     /**
-     * Override to customize when to compact the buffer
-     * By default, compacts when more than 1000 items have been consumed
+     * Override to customize when to compact the buffer.
+     * Compacts when more than 1000 items have been consumed AND we've consumed
+     * at least half the buffer. The second condition prevents O(n²) behaviour
+     * when a single large chunk is fed all at once: without it, compact() is
+     * called O(n/1000) times, each copying O(n) elements → O(n²) total.
+     * By requiring bufferIndex ≥ buffer.length/2 we ensure at most O(log n)
+     * compactions, for O(n) total copies.
      *
      * @returns boolean indicating whether to compact the buffer
      */
     canCompact() {
-        return this.bufferIndex > 1000;
+        return (this.bufferIndex >= 1000 &&
+            this.bufferIndex >= this.buffer.length >> 1);
     }
     /**
      * Generates parsed output items from the buffer.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdf-lite",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "main": "dist/index.js",
   "type": "module",
   "exports": {