perf: reduce allocation churn in operator serialization (#31)

Author: ntedvs

src/content/operators.ts

@@ -15,7 +15,6 @@
  * This module provides type-safe creation and serialization of operators.
  */
 
-import { concatBytes } from "#src/helpers/buffer";
 import { formatPdfNumber } from "#src/helpers/format";
 import { ByteWriter } from "#src/io/byte-writer";
 import type { PdfArray } from "#src/objects/pdf-array";
@@ -26,7 +25,6 @@ import type { PdfString } from "#src/objects/pdf-string";
 /** Valid operand types */
 export type Operand = number | string | PdfName | PdfString | PdfArray | PdfDict;
 
-const encoder = new TextEncoder();
 const SPACE = 0x20;
 
 /** All PDF content stream operator names */
@@ -145,24 +143,27 @@ export class Operator {
   }
 
   /**
-   * Serialize to bytes for content stream output.
-   * Format: "operand1 operand2 ... operator"
+   * Write operator bytes directly into a shared ByteWriter.
+   * Avoids intermediate allocations compared to toBytes().
    */
-  toBytes(): Uint8Array {
-    if (this.operands.length === 0) {
-      return encoder.encode(this.op);
-    }
-
-    const parts: Uint8Array[] = [];
-
+  writeTo(writer: ByteWriter): void {
     for (const operand of this.operands) {
-      parts.push(serializeOperand(operand));
-      parts.push(new Uint8Array([SPACE]));
+      writeOperand(writer, operand);
+      writer.writeByte(SPACE);
     }
 
-    parts.push(encoder.encode(this.op));
+    writer.writeAscii(this.op);
+  }
+
+  /**
+   * Serialize to bytes for content stream output.
+   * Format: "operand1 operand2 ... operator"
+   */
+  toBytes(): Uint8Array {
+    const writer = new ByteWriter(undefined, { initialSize: 64 });
+    this.writeTo(writer);
 
-    return concatBytes(parts);
+    return writer.toBytes();
   }
 
   /**
@@ -174,29 +175,28 @@ export class Operator {
   }
 
   /**
-   * Get byte length when serialized (for pre-allocation).
+   * Get byte length when serialized.
+   *
+   * Should be avoided in performance-critical paths, use {@link writeTo} instead.
    */
   byteLength(): number {
     return this.toBytes().length;
   }
 }
 
-/**
- * Serialize an operand to bytes.
- */
-function serializeOperand(operand: Operand): Uint8Array {
+/** Write an operand directly into a ByteWriter. */
+function writeOperand(writer: ByteWriter, operand: Operand): void {
   if (typeof operand === "number") {
-    return encoder.encode(formatPdfNumber(operand));
+    writer.writeAscii(formatPdfNumber(operand));
+    return;
   }
 
   if (typeof operand === "string") {
     // Assume already formatted (e.g., "/FontName")
-    return encoder.encode(operand);
+    writer.writeAscii(operand);
+    return;
   }
 
-  // PdfName, PdfString, PdfArray, PdfDict all have toBytes()
-  const writer = new ByteWriter();
+  // PdfName, PdfString, PdfArray, PdfDict all have toBytes(writer)
   operand.toBytes(writer);
-
-  return writer.toBytes();
 }

src/drawing/serialize.ts

@@ -3,29 +3,30 @@
  */
 
 import type { Operator } from "#src/content/operators";
-import { concatBytes } from "#src/helpers/buffer";
+import { ByteWriter } from "#src/io/byte-writer";
+
+const NEWLINE = 0x0a;
 
 /**
  * Serialize operators to bytes for content streams.
  *
- * Uses Operator.toBytes() directly to avoid UTF-8 round-trip corruption
- * of non-ASCII bytes in PdfString operands (e.g., WinAnsi-encoded text).
+ * Uses Operator.writeTo() to write directly into a shared ByteWriter,
+ * avoiding per-operator intermediate allocations.
  */
 export function serializeOperators(ops: Operator[]): Uint8Array {
   if (ops.length === 0) {
     return new Uint8Array(0);
   }
 
-  const newline = new Uint8Array([0x0a]);
-  const parts: Uint8Array[] = [];
+  const writer = new ByteWriter(undefined, { initialSize: ops.length * 24 });
 
   for (let i = 0; i < ops.length; i++) {
     if (i > 0) {
-      parts.push(newline);
+      writer.writeByte(NEWLINE);
     }
 
-    parts.push(ops[i].toBytes());
+    ops[i].writeTo(writer);
   }
 
-  return concatBytes(parts);
+  return writer.toBytes();
 }