pdf-lite 1.0.1-alpha.2 → 1.0.1

package/dist/utils/escapeString.js

@@ -0,0 +1,43 @@
+import { stringToBytes } from './stringToBytes';
+/**
+ * Escapes special characters in a PDF string according to PDF specification.
+ * Escapes parentheses, backslashes, line feeds, and carriage returns.
+ *
+ * @param bytes - The byte array or string to escape.
+ * @returns A new byte array with escaped characters.
+ *
+ * @example
+ * ```typescript
+ * escapeString('Hello (World)') // Escapes the parentheses
+ * ```
+ */
+export function escapeString(bytes) {
+    if (typeof bytes === 'string') {
+        bytes = stringToBytes(bytes);
+    }
+    const result = [];
+    const BACKSLASH = 0x5c;
+    for (const b of bytes) {
+        switch (b) {
+            case 0x28:
+                result.push(BACKSLASH, 0x28);
+                break; // (
+            case 0x29:
+                result.push(BACKSLASH, 0x29);
+                break; // )
+            case BACKSLASH:
+                result.push(BACKSLASH, BACKSLASH);
+                break; // \
+            case 0x0a:
+                result.push(BACKSLASH, 0x6e);
+                break; // LF
+            case 0x0d:
+                result.push(BACKSLASH, 0x72);
+                break; // CR
+            default:
+                result.push(b);
+                break;
+        }
+    }
+    return new Uint8Array(result);
+}

package/dist/utils/hexBytesToBytes.d.ts

@@ -0,0 +1,15 @@
+import { ByteArray } from '../types';
+/**
+ * Converts a byte array containing hexadecimal ASCII characters to raw bytes.
+ * Each pair of hex character bytes is converted to a single byte value.
+ *
+ * @param hex - The byte array containing hex character codes.
+ * @returns A byte array with decoded values.
+ *
+ * @example
+ * ```typescript
+ * // 'FF' as bytes (0x46, 0x46) becomes 0xFF
+ * hexBytesToBytes(new Uint8Array([70, 70])) // Returns Uint8Array([255])
+ * ```
+ */
+export declare function hexBytesToBytes(hex: ByteArray): ByteArray;

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

@@ -1,5 +1,3 @@
-import { ByteArray } from '../types'
-
 /**
  * Converts a byte array containing hexadecimal ASCII characters to raw bytes.
  * Each pair of hex character bytes is converted to a single byte value.
@@ -13,10 +11,10 @@ import { ByteArray } from '../types'
  * hexBytesToBytes(new Uint8Array([70, 70])) // Returns Uint8Array([255])
  * ```
  */
-export function hexBytesToBytes(hex: ByteArray): ByteArray {
-    const bytes = new Uint8Array(hex.length / 2)
+export function hexBytesToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
     for (let i = 0; i < hex.length; i += 2) {
-        bytes[i / 2] = parseInt(String.fromCharCode(hex[i], hex[i + 1]), 16)
+        bytes[i / 2] = parseInt(String.fromCharCode(hex[i], hex[i + 1]), 16);
     }
-    return bytes
+    return bytes;
 }

package/dist/utils/hexBytesToString.d.ts

@@ -0,0 +1,13 @@
+import { ByteArray } from '../types';
+/**
+ * Converts a byte array to a lowercase hexadecimal string.
+ *
+ * @param bytes - The byte array to convert.
+ * @returns A lowercase hexadecimal string representation.
+ *
+ * @example
+ * ```typescript
+ * hexBytesToString(new Uint8Array([255, 0])) // Returns 'ff00'
+ * ```
+ */
+export declare function hexBytesToString(bytes: ByteArray): string;

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

@@ -1,5 +1,3 @@
-import { ByteArray } from '../types'
-
 /**
  * Converts a byte array to a lowercase hexadecimal string.
  *
@@ -11,11 +9,11 @@ import { ByteArray } from '../types'
  * hexBytesToString(new Uint8Array([255, 0])) // Returns 'ff00'
  * ```
  */
-export function hexBytesToString(bytes: ByteArray): string {
-    let hex = ''
+export function hexBytesToString(bytes) {
+    let hex = '';
     for (let i = 0; i < bytes.length; i++) {
-        const byte = bytes[i].toString(16)
-        hex += byte.length === 1 ? '0' + byte : byte
+        const byte = bytes[i].toString(16);
+        hex += byte.length === 1 ? '0' + byte : byte;
     }
-    return hex
+    return hex;
 }

package/dist/utils/hexToBytes.d.ts

@@ -0,0 +1,13 @@
+import { ByteArray } from '../types';
+/**
+ * Converts a hexadecimal string to a byte array.
+ *
+ * @param hex - The hexadecimal string to convert.
+ * @returns A byte array containing the decoded values.
+ *
+ * @example
+ * ```typescript
+ * hexToBytes('FF00') // Returns Uint8Array([255, 0])
+ * ```
+ */
+export declare function hexToBytes(hex: string): ByteArray;

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

@@ -1,7 +1,5 @@
-import { ByteArray } from '../types'
-import { hexBytesToBytes } from './hexBytesToBytes'
-import { stringToBytes } from './stringToBytes'
-
+import { hexBytesToBytes } from './hexBytesToBytes';
+import { stringToBytes } from './stringToBytes';
 /**
  * Converts a hexadecimal string to a byte array.
  *
@@ -13,6 +11,6 @@ import { stringToBytes } from './stringToBytes'
  * hexToBytes('FF00') // Returns Uint8Array([255, 0])
  * ```
  */
-export function hexToBytes(hex: string): ByteArray {
-    return hexBytesToBytes(stringToBytes(hex))
+export function hexToBytes(hex) {
+    return hexBytesToBytes(stringToBytes(hex));
 }

package/dist/utils/padBytes.d.ts

@@ -0,0 +1,15 @@
+import { ByteArray } from '../types';
+/**
+ * Pads a byte array to a specified length with trailing zeros.
+ *
+ * @param bytes - The byte array to pad.
+ * @param length - The target length for the padded array.
+ * @returns A new byte array padded to the specified length.
+ * @throws Error if the input array is already longer than the target length.
+ *
+ * @example
+ * ```typescript
+ * padBytes(new Uint8Array([1, 2]), 4) // Returns Uint8Array([1, 2, 0, 0])
+ * ```
+ */
+export declare function padBytes(bytes: ByteArray, length: number): ByteArray;

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

@@ -1,5 +1,3 @@
-import { ByteArray } from '../types'
-
 /**
  * Pads a byte array to a specified length with trailing zeros.
  *
@@ -13,13 +11,11 @@ import { ByteArray } from '../types'
  * padBytes(new Uint8Array([1, 2]), 4) // Returns Uint8Array([1, 2, 0, 0])
  * ```
  */
-export function padBytes(bytes: ByteArray, length: number): ByteArray {
+export function padBytes(bytes, length) {
     if (bytes.length > length) {
-        throw new Error(
-            `Cannot pad bytes: current length ${bytes.length} is greater than or equal to target length ${length}.`,
-        )
+        throw new Error(`Cannot pad bytes: current length ${bytes.length} is greater than or equal to target length ${length}.`);
     }
-    const padded = new Uint8Array(length)
-    padded.set(bytes)
-    return padded
+    const padded = new Uint8Array(length);
+    padded.set(bytes);
+    return padded;
 }

package/dist/utils/predictors.d.ts

@@ -0,0 +1,113 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { ByteArray, DecodeParms } from '../types.js';
+/**
+ * Handles PNG and TIFF predictor encoding and decoding for PDF streams.
+ * Predictors are used to improve compression efficiency by transforming
+ * image data before or after compression.
+ */
+export declare class Predictor {
+    /**
+     * Decodes data that was encoded with a predictor.
+     *
+     * @param data - The encoded data to decode.
+     * @param params - Optional decode parameters including Predictor, Columns, Colors, and BitsPerComponent.
+     * @returns The decoded byte array.
+     *
+     * @example
+     * ```typescript
+     * const decoded = Predictor.decode(encodedData, { Predictor: 12, Columns: 100 })
+     * ```
+     */
+    static decode(data: ByteArray, params?: DecodeParms): ByteArray;
+    /**
+     * Encodes data using a predictor algorithm.
+     *
+     * @param data - The data to encode.
+     * @param params - Optional encode parameters including Predictor, Columns, Colors, and BitsPerComponent.
+     * @param PdfStreamFilterType - The PNG filter type to use for encoding.
+     * @returns The encoded byte array.
+     *
+     * @example
+     * ```typescript
+     * const encoded = Predictor.encode(rawData, { Predictor: 12, Columns: 100 }, 1)
+     * ```
+     */
+    static encode(data: ByteArray, params?: DecodeParms, PdfStreamFilterType?: number): ByteArray;
+    /**
+     * Decodes TIFF predictor encoded data.
+     *
+     * @param data - The TIFF encoded data.
+     * @param columns - The number of columns in the image.
+     * @param bpp - Bytes per pixel.
+     * @returns The decoded byte array.
+     */
+    static tiffDecode(data: ByteArray, columns: number, bpp: number): ByteArray;
+    /**
+     * Encodes data using TIFF predictor.
+     *
+     * @param data - The data to encode.
+     * @param columns - The number of columns in the image.
+     * @param bpp - Bytes per pixel.
+     * @returns The TIFF encoded byte array.
+     */
+    static tiffEncode(data: ByteArray, columns: number, bpp: number): ByteArray;
+    /**
+     * Decodes PNG predictor encoded data.
+     *
+     * @param data - The PNG encoded data.
+     * @param columns - The number of columns in the image.
+     * @param bpp - Bytes per pixel.
+     * @returns The decoded byte array.
+     * @throws Error if an unsupported PNG filter type is encountered.
+     */
+    static pngDecode(data: ByteArray, columns: number, bpp: number): ByteArray;
+    /**
+     * Encodes data using PNG predictor.
+     *
+     * @param data - The data to encode.
+     * @param columns - The number of columns in the image.
+     * @param bpp - Bytes per pixel.
+     * @param PdfStreamFilterType - The PNG filter type (0-4) to use.
+     * @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;
+    /**
+     * Implements the Paeth predictor algorithm used in PNG filtering.
+     *
+     * @param a - The left pixel value.
+     * @param b - The above pixel value.
+     * @param c - The upper-left pixel value.
+     * @returns The predicted pixel value.
+     */
+    private static paethPredictor;
+    /**
+     * Extracts decode parameters from a PDF dictionary.
+     *
+     * @param decodeParms - Optional PDF dictionary containing decode parameters.
+     * @returns The decode parameters object or null if not applicable.
+     *
+     * @example
+     * ```typescript
+     * const params = Predictor.getDecodeParms(dictionary)
+     * if (params) {
+     *   console.log(params.Predictor)
+     * }
+     * ```
+     */
+    static getDecodeParms(decodeParms?: PdfDictionary): DecodeParms | null;
+    /**
+     * Checks if the decode parameters can be handled by this predictor.
+     *
+     * @param decodeParms - Optional PDF dictionary containing decode parameters.
+     * @returns True if the parameters can be handled, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * if (Predictor.canHandleDecodeParms(dictionary)) {
+     *   // Process with predictor
+     * }
+     * ```
+     */
+    static canHandleDecodeParms(decodeParms?: PdfDictionary): boolean;
+}