pdf-lite 1.0.1-alpha.2 → 1.0.1

package/{packages/pdf-lite/src/utils/predictors.ts → dist/utils/predictors.js}

@@ -1,8 +1,4 @@
-import { PdfDictionary } from '../core/objects/pdf-dictionary.js'
-import { PdfNumber } from '../core/objects/pdf-number.js'
-import { PdfObject } from '../core/objects/pdf-object.js'
-import { ByteArray, DecodeParms } from '../types.js'
-
+import { PdfNumber } from '../core/objects/pdf-number.js';
 /**
  * Handles PNG and TIFF predictor encoding and decoding for PDF streams.
  * Predictors are used to improve compression efficiency by transforming
@@ -21,23 +17,20 @@ export class Predictor {
      * const decoded = Predictor.decode(encodedData, { Predictor: 12, Columns: 100 })
      * ```
      */
-    static decode(data: ByteArray, params: DecodeParms = {}): ByteArray {
-        const predictor = params.Predictor ?? 1
-        const columns = params.Columns ?? 1
-        const colors = params.Colors ?? 1
-        const bpc = params.BitsPerComponent ?? 8
-
-        const bpp = Math.ceil((colors * bpc) / 8)
-
+    static decode(data, params = {}) {
+        const predictor = params.Predictor ?? 1;
+        const columns = params.Columns ?? 1;
+        const colors = params.Colors ?? 1;
+        const bpc = params.BitsPerComponent ?? 8;
+        const bpp = Math.ceil((colors * bpc) / 8);
         if (predictor === 2) {
-            return this.tiffDecode(data, columns, bpp)
-        } else if (predictor >= 10 && predictor <= 15) {
-            return this.pngDecode(data, columns, bpp)
+            return this.tiffDecode(data, columns, bpp);
         }
-
-        return data
+        else if (predictor >= 10 && predictor <= 15) {
+            return this.pngDecode(data, columns, bpp);
+        }
+        return data;
     }
-
     /**
      * Encodes data using a predictor algorithm.
      *
@@ -51,27 +44,20 @@ export class Predictor {
      * const encoded = Predictor.encode(rawData, { Predictor: 12, Columns: 100 }, 1)
      * ```
      */
-    static encode(
-        data: ByteArray,
-        params: DecodeParms = {},
-        PdfStreamFilterType: number = 0,
-    ): ByteArray {
-        const predictor = params.Predictor ?? 1
-        const columns = params.Columns ?? 1
-        const colors = params.Colors ?? 1
-        const bpc = params.BitsPerComponent ?? 8
-
-        const bpp = Math.ceil((colors * bpc) / 8)
-
+    static encode(data, params = {}, PdfStreamFilterType = 0) {
+        const predictor = params.Predictor ?? 1;
+        const columns = params.Columns ?? 1;
+        const colors = params.Colors ?? 1;
+        const bpc = params.BitsPerComponent ?? 8;
+        const bpp = Math.ceil((colors * bpc) / 8);
         if (predictor === 2) {
-            return this.tiffEncode(data, columns, bpp)
-        } else if (predictor >= 10 && predictor <= 15) {
-            return this.pngEncode(data, columns, bpp, PdfStreamFilterType)
+            return this.tiffEncode(data, columns, bpp);
+        }
+        else if (predictor >= 10 && predictor <= 15) {
+            return this.pngEncode(data, columns, bpp, PdfStreamFilterType);
         }
-
-        return data
+        return data;
     }
-
     /**
      * Decodes TIFF predictor encoded data.
      *
@@ -80,26 +66,19 @@ export class Predictor {
      * @param bpp - Bytes per pixel.
      * @returns The decoded byte array.
      */
-    static tiffDecode(
-        data: ByteArray,
-        columns: number,
-        bpp: number,
-    ): ByteArray {
-        const rowLength = columns * bpp
-        const output = new Uint8Array(data.length)
-
+    static tiffDecode(data, columns, bpp) {
+        const rowLength = columns * bpp;
+        const output = new Uint8Array(data.length);
         for (let i = 0; i < data.length; i += rowLength) {
             for (let j = 0; j < rowLength; j++) {
                 output[i + j] =
                     j < bpp
                         ? data[i + j]
-                        : (data[i + j] + output[i + j - bpp]) & 0xff
+                        : (data[i + j] + output[i + j - bpp]) & 0xff;
             }
         }
-
-        return output
+        return output;
     }
-
     /**
      * Encodes data using TIFF predictor.
      *
@@ -108,26 +87,19 @@ export class Predictor {
      * @param bpp - Bytes per pixel.
      * @returns The TIFF encoded byte array.
      */
-    static tiffEncode(
-        data: ByteArray,
-        columns: number,
-        bpp: number,
-    ): ByteArray {
-        const rowLength = columns * bpp
-        const output = new Uint8Array(data.length)
-
+    static tiffEncode(data, columns, bpp) {
+        const rowLength = columns * bpp;
+        const output = new Uint8Array(data.length);
         for (let i = 0; i < data.length; i += rowLength) {
             for (let j = 0; j < rowLength; j++) {
                 output[i + j] =
                     j < bpp
                         ? data[i + j]
-                        : (data[i + j] - data[i + j - bpp] + 256) & 0xff
+                        : (data[i + j] - data[i + j - bpp] + 256) & 0xff;
             }
         }
-
-        return output
+        return output;
     }
-
     /**
      * Decodes PNG predictor encoded data.
      *
@@ -137,53 +109,47 @@ export class Predictor {
      * @returns The decoded byte array.
      * @throws Error if an unsupported PNG filter type is encountered.
      */
-    static pngDecode(data: ByteArray, columns: number, bpp: number): ByteArray {
-        const rowLength = columns * bpp
-        const output: number[] = []
-
-        for (let i = 0; i < data.length; ) {
-            const filter = data[i]
-            const row = data.slice(i + 1, i + 1 + rowLength)
-            const prior = output.slice(output.length - rowLength, output.length)
-
-            const decodedRow = new Uint8Array(rowLength)
+    static pngDecode(data, columns, bpp) {
+        const rowLength = columns * bpp;
+        const output = [];
+        for (let i = 0; i < data.length;) {
+            const filter = data[i];
+            const row = data.slice(i + 1, i + 1 + rowLength);
+            const prior = output.slice(output.length - rowLength, output.length);
+            const decodedRow = new Uint8Array(rowLength);
             for (let j = 0; j < rowLength; j++) {
-                const left = j >= bpp ? decodedRow[j - bpp] : 0
-                const up = prior[j] ?? 0
-                const upperLeft = j >= bpp ? (prior[j - bpp] ?? 0) : 0
-
+                const left = j >= bpp ? decodedRow[j - bpp] : 0;
+                const up = prior[j] ?? 0;
+                const upperLeft = j >= bpp ? (prior[j - bpp] ?? 0) : 0;
                 switch (filter) {
                     case 0:
-                        decodedRow[j] = row[j]
-                        break
+                        decodedRow[j] = row[j];
+                        break;
                     case 1:
-                        decodedRow[j] = (row[j] + left) & 0xff
-                        break
+                        decodedRow[j] = (row[j] + left) & 0xff;
+                        break;
                     case 2:
-                        decodedRow[j] = (row[j] + up) & 0xff
-                        break
+                        decodedRow[j] = (row[j] + up) & 0xff;
+                        break;
                     case 3:
                         decodedRow[j] =
-                            (row[j] + Math.floor((left + up) / 2)) & 0xff
-                        break
+                            (row[j] + Math.floor((left + up) / 2)) & 0xff;
+                        break;
                     case 4:
                         decodedRow[j] =
                             (row[j] +
                                 this.paethPredictor(left, up, upperLeft)) &
-                            0xff
-                        break
+                                0xff;
+                        break;
                     default:
-                        throw new Error(`Unsupported PNG filter: ${filter}`)
+                        throw new Error(`Unsupported PNG filter: ${filter}`);
                 }
             }
-
-            output.push(...decodedRow)
-            i += 1 + rowLength
+            output.push(...decodedRow);
+            i += 1 + rowLength;
         }
-
-        return new Uint8Array(output)
+        return new Uint8Array(output);
     }
-
     /**
      * Encodes data using PNG predictor.
      *
@@ -194,60 +160,47 @@ export class Predictor {
      * @returns The PNG encoded byte array.
      * @throws Error if an unsupported PNG filter type is specified.
      */
-    static pngEncode(
-        data: ByteArray,
-        columns: number,
-        bpp: number,
-        PdfStreamFilterType: number,
-    ): ByteArray {
-        const rowLength = columns * bpp
-        const output: number[] = []
-        let prior = new Uint8Array(rowLength)
-
+    static pngEncode(data, columns, bpp, PdfStreamFilterType) {
+        const rowLength = columns * bpp;
+        const output = [];
+        let prior = new Uint8Array(rowLength);
         for (let i = 0; i < data.length; i += rowLength) {
-            const row = data.slice(i, i + rowLength)
-            const encodedRow = new Uint8Array(rowLength)
-
+            const row = data.slice(i, i + rowLength);
+            const encodedRow = new Uint8Array(rowLength);
             for (let j = 0; j < rowLength; j++) {
-                const left = j >= bpp ? row[j - bpp] : 0
-                const up = prior[j] ?? 0
-                const upperLeft = j >= bpp ? (prior[j - bpp] ?? 0) : 0
-
+                const left = j >= bpp ? row[j - bpp] : 0;
+                const up = prior[j] ?? 0;
+                const upperLeft = j >= bpp ? (prior[j - bpp] ?? 0) : 0;
                 switch (PdfStreamFilterType) {
                     case 0:
-                        encodedRow[j] = row[j]
-                        break
+                        encodedRow[j] = row[j];
+                        break;
                     case 1:
-                        encodedRow[j] = (row[j] - left + 256) & 0xff
-                        break
+                        encodedRow[j] = (row[j] - left + 256) & 0xff;
+                        break;
                     case 2:
-                        encodedRow[j] = (row[j] - up + 256) & 0xff
-                        break
+                        encodedRow[j] = (row[j] - up + 256) & 0xff;
+                        break;
                     case 3:
                         encodedRow[j] =
-                            (row[j] - Math.floor((left + up) / 2) + 256) & 0xff
-                        break
+                            (row[j] - Math.floor((left + up) / 2) + 256) & 0xff;
+                        break;
                     case 4:
                         encodedRow[j] =
                             (row[j] -
                                 this.paethPredictor(left, up, upperLeft) +
                                 256) &
-                            0xff
-                        break
+                                0xff;
+                        break;
                     default:
-                        throw new Error(
-                            `Unsupported PNG filter: ${PdfStreamFilterType}`,
-                        )
+                        throw new Error(`Unsupported PNG filter: ${PdfStreamFilterType}`);
                 }
             }
-
-            output.push(PdfStreamFilterType, ...encodedRow)
-            prior = row
+            output.push(PdfStreamFilterType, ...encodedRow);
+            prior = row;
         }
-
-        return new Uint8Array(output)
+        return new Uint8Array(output);
     }
-
     /**
      * Implements the Paeth predictor algorithm used in PNG filtering.
      *
@@ -256,17 +209,17 @@ export class Predictor {
      * @param c - The upper-left pixel value.
      * @returns The predicted pixel value.
      */
-    private static paethPredictor(a: number, b: number, c: number): number {
-        const p = a + b - c
-        const pa = Math.abs(p - a)
-        const pb = Math.abs(p - b)
-        const pc = Math.abs(p - c)
-
-        if (pa <= pb && pa <= pc) return a
-        if (pb <= pc) return b
-        return c
+    static paethPredictor(a, b, c) {
+        const p = a + b - c;
+        const pa = Math.abs(p - a);
+        const pb = Math.abs(p - b);
+        const pc = Math.abs(p - c);
+        if (pa <= pb && pa <= pc)
+            return a;
+        if (pb <= pc)
+            return b;
+        return c;
     }
-
     /**
      * Extracts decode parameters from a PDF dictionary.
      *
@@ -281,35 +234,29 @@ export class Predictor {
      * }
      * ```
      */
-    static getDecodeParms(decodeParms?: PdfDictionary): DecodeParms | null {
+    static getDecodeParms(decodeParms) {
         if (!decodeParms) {
-            return null
+            return null;
         }
-
-        const predictor = decodeParms.get('Predictor')?.as(PdfNumber)?.value
-
+        const predictor = decodeParms.get('Predictor')?.as(PdfNumber)?.value;
         if (predictor === undefined) {
-            return null
+            return null;
         }
-
         if (predictor <= 1 || predictor > 15) {
-            return null
+            return null;
         }
-
         const BitsPerComponent = decodeParms
             .get('BitsPerComponent')
-            ?.as(PdfNumber)
-        const Columns = decodeParms.get('Columns')?.as(PdfNumber)
-        const Colors = decodeParms.get('Colors')?.as(PdfNumber)
-
+            ?.as(PdfNumber);
+        const Columns = decodeParms.get('Columns')?.as(PdfNumber);
+        const Colors = decodeParms.get('Colors')?.as(PdfNumber);
         return {
             BitsPerComponent: BitsPerComponent?.value,
             Columns: Columns?.value,
             Predictor: predictor,
             Colors: Colors?.value,
-        }
+        };
     }
-
     /**
      * Checks if the decode parameters can be handled by this predictor.
      *
@@ -323,10 +270,10 @@ export class Predictor {
      * }
      * ```
      */
-    static canHandleDecodeParms(decodeParms?: PdfDictionary): boolean {
+    static canHandleDecodeParms(decodeParms) {
         if (Predictor.getDecodeParms(decodeParms) === null) {
-            return false
+            return false;
         }
-        return true
+        return true;
     }
 }

package/dist/utils/replaceInBuffer.d.ts

@@ -0,0 +1,22 @@
+import { ByteArray } from '../types';
+/**
+ * Replaces occurrences of a search buffer with a replacement buffer within a target buffer.
+ *
+ * @typeParam T - The type of the target buffer, extending ByteArray.
+ * @param searchBuffer - The byte pattern to search for.
+ * @param replaceBuffer - The byte pattern to replace with.
+ * @param targetBuffer - The buffer to search within.
+ * @param multiple - Whether to replace all occurrences or just the first. Defaults to false.
+ * @returns A new byte array with the replacements made.
+ * @throws Error if the search buffer is not found in the target buffer.
+ *
+ * @example
+ * ```typescript
+ * const result = replaceInBuffer(
+ *   new Uint8Array([1, 2]),
+ *   new Uint8Array([3, 4, 5]),
+ *   new Uint8Array([0, 1, 2, 6])
+ * ) // Returns Uint8Array([0, 3, 4, 5, 6])
+ * ```
+ */
+export declare function replaceInBuffer<T extends ByteArray>(searchBuffer: ByteArray, replaceBuffer: ByteArray, targetBuffer: T, multiple?: boolean): ByteArray;

package/{packages/pdf-lite/src/utils/replaceInBuffer.ts → dist/utils/replaceInBuffer.js}

@@ -1,5 +1,3 @@
-import { ByteArray } from '../types'
-
 /**
  * Replaces occurrences of a search buffer with a replacement buffer within a target buffer.
  *
@@ -20,37 +18,30 @@ import { ByteArray } from '../types'
  * ) // Returns Uint8Array([0, 3, 4, 5, 6])
  * ```
  */
-export function replaceInBuffer<T extends ByteArray>(
-    searchBuffer: ByteArray,
-    replaceBuffer: ByteArray,
-    targetBuffer: T,
-    multiple: boolean = false,
-): ByteArray {
-    const searchLength = searchBuffer.length
-    const replaceLength = replaceBuffer.length
-    const targetLength = targetBuffer.length
-    const result = new Uint8Array(targetLength - searchLength + replaceLength)
-    let found = false
-    let offset = 0
+export function replaceInBuffer(searchBuffer, replaceBuffer, targetBuffer, multiple = false) {
+    const searchLength = searchBuffer.length;
+    const replaceLength = replaceBuffer.length;
+    const targetLength = targetBuffer.length;
+    const result = new Uint8Array(targetLength - searchLength + replaceLength);
+    let found = false;
+    let offset = 0;
     for (let i = 0; i < targetLength; i++) {
-        if (
-            (multiple || !found) &&
+        if ((multiple || !found) &&
             i <= targetLength - searchLength &&
             targetBuffer
                 .subarray(i, i + searchLength)
-                .every((value, index) => value === searchBuffer[index])
-        ) {
-            result.set(replaceBuffer, offset)
-            offset += replaceLength
-            i += searchLength - 1 // Skip the length of the search buffer
-            found = true
-        } else {
-            result[offset++] = targetBuffer[i]
+                .every((value, index) => value === searchBuffer[index])) {
+            result.set(replaceBuffer, offset);
+            offset += replaceLength;
+            i += searchLength - 1; // Skip the length of the search buffer
+            found = true;
+        }
+        else {
+            result[offset++] = targetBuffer[i];
         }
     }
-
     if (!found) {
-        throw new Error(`Search buffer not found in target buffer`)
+        throw new Error(`Search buffer not found in target buffer`);
     }
-    return result
+    return result;
 }

package/dist/utils/stringToBytes.d.ts

@@ -0,0 +1,14 @@
+import { ByteArray } from '../types';
+/**
+ * Converts a string or byte array to a byte array using UTF-8 encoding.
+ * If the input is already a byte array, it is returned as-is.
+ *
+ * @param str - The string or byte array to convert.
+ * @returns The input as a byte array.
+ *
+ * @example
+ * ```typescript
+ * stringToBytes('Hello') // Returns Uint8Array([72, 101, 108, 108, 111])
+ * ```
+ */
+export declare function stringToBytes(str: string | ByteArray): ByteArray;

package/{packages/pdf-lite/src/utils/stringToBytes.ts → dist/utils/stringToBytes.js}

@@ -1,5 +1,3 @@
-import { ByteArray } from '../types'
-
 /**
  * Converts a string or byte array to a byte array using UTF-8 encoding.
  * If the input is already a byte array, it is returned as-is.
@@ -12,11 +10,12 @@ import { ByteArray } from '../types'
  * stringToBytes('Hello') // Returns Uint8Array([72, 101, 108, 108, 111])
  * ```
  */
-export function stringToBytes(str: string | ByteArray): ByteArray {
+export function stringToBytes(str) {
     if (typeof str === 'string') {
-        const encoder = new TextEncoder()
-        return encoder.encode(str) as ByteArray
-    } else {
-        return str
+        const encoder = new TextEncoder();
+        return encoder.encode(str);
+    }
+    else {
+        return str;
     }
 }

package/dist/utils/stringToHexBytes.d.ts

@@ -0,0 +1,15 @@
+import { ByteArray } from '../types';
+/**
+ * Converts a hexadecimal string (optionally with angle brackets) to a byte array.
+ * Strips any surrounding angle brackets before conversion.
+ *
+ * @param str - The hexadecimal string to convert, optionally wrapped in angle brackets.
+ * @returns A byte array with the decoded values.
+ *
+ * @example
+ * ```typescript
+ * stringToHexBytes('<FF00>') // Returns Uint8Array([255, 0])
+ * stringToHexBytes('FF00') // Also returns Uint8Array([255, 0])
+ * ```
+ */
+export declare function stringToHexBytes(str: string): ByteArray;

package/{packages/pdf-lite/src/utils/stringToHexBytes.ts → dist/utils/stringToHexBytes.js}

@@ -1,5 +1,3 @@
-import { ByteArray } from '../types'
-
 /**
  * Converts a hexadecimal string (optionally with angle brackets) to a byte array.
  * Strips any surrounding angle brackets before conversion.
@@ -13,11 +11,11 @@ import { ByteArray } from '../types'
  * stringToHexBytes('FF00') // Also returns Uint8Array([255, 0])
  * ```
  */
-export function stringToHexBytes(str: string): ByteArray {
-    const hex = str.replace(/<|>/g, '')
-    const bytes = new Uint8Array(hex.length / 2)
+export function stringToHexBytes(str) {
+    const hex = str.replace(/<|>/g, '');
+    const bytes = new Uint8Array(hex.length / 2);
     for (let i = 0; i < hex.length; i += 2) {
-        bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16)
+        bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
     }
-    return bytes
+    return bytes;
 }

package/dist/utils/unescapeString.d.ts

@@ -0,0 +1,16 @@
+import { ByteArray } from '../types';
+/**
+ * Unescapes a PDF literal string by processing escape sequences.
+ * Handles escape sequences for special characters including newlines, tabs,
+ * backslashes, parentheses, and octal character codes.
+ *
+ * @param input - The escaped byte array to unescape.
+ * @returns A new byte array with escape sequences converted to their literal values.
+ *
+ * @example
+ * ```typescript
+ * // Unescapes '\n' to a literal newline
+ * unescapeString(new Uint8Array([0x5c, 0x6e])) // Returns Uint8Array([0x0a])
+ * ```
+ */
+export declare function unescapeString(input: ByteArray): ByteArray;