pdf-lite 1.0.1-alpha.2 → 1.0.1

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

@@ -1,9 +1,7 @@
-import { deflate, Inflate } from 'pako'
-import { bytesToHex } from './bytesToHex.js'
-import { AlgorithmIdentifier } from 'pki-lite/algorithms/AlgorithmIdentifier'
-import 'pki-lite-crypto-extended'
-import { ByteArray } from '../types.js'
-
+import { deflate, Inflate } from 'pako';
+import { bytesToHex } from './bytesToHex.js';
+import { AlgorithmIdentifier } from 'pki-lite/algorithms/AlgorithmIdentifier';
+import 'pki-lite-crypto-extended';
 /**
  * Computes the SHA-1 hash of the input data.
  *
@@ -15,10 +13,9 @@ import { ByteArray } from '../types.js'
  * const hash = await sha1(new Uint8Array([1, 2, 3]))
  * ```
  */
-export async function sha1(input: ByteArray): Promise<ByteArray> {
-    return AlgorithmIdentifier.digestAlgorithm('SHA-1').digest(input)
+export async function sha1(input) {
+    return AlgorithmIdentifier.digestAlgorithm('SHA-1').digest(input);
 }
-
 /**
  * Computes the SHA-256 hash of the input data.
  *
@@ -30,10 +27,9 @@ export async function sha1(input: ByteArray): Promise<ByteArray> {
  * const hash = await sha256(new Uint8Array([1, 2, 3]))
  * ```
  */
-export async function sha256(input: ByteArray): Promise<ByteArray> {
-    return AlgorithmIdentifier.digestAlgorithm('SHA-256').digest(input)
+export async function sha256(input) {
+    return AlgorithmIdentifier.digestAlgorithm('SHA-256').digest(input);
 }
-
 /**
  * Computes the SHA-384 hash of the input data.
  *
@@ -45,10 +41,9 @@ export async function sha256(input: ByteArray): Promise<ByteArray> {
  * const hash = await sha384(new Uint8Array([1, 2, 3]))
  * ```
  */
-export async function sha384(input: ByteArray): Promise<ByteArray> {
-    return AlgorithmIdentifier.digestAlgorithm('SHA-384').digest(input)
+export async function sha384(input) {
+    return AlgorithmIdentifier.digestAlgorithm('SHA-384').digest(input);
 }
-
 /**
  * Computes the SHA-512 hash of the input data.
  *
@@ -60,10 +55,9 @@ export async function sha384(input: ByteArray): Promise<ByteArray> {
  * const hash = await sha512(new Uint8Array([1, 2, 3]))
  * ```
  */
-export async function sha512(input: ByteArray): Promise<ByteArray> {
-    return AlgorithmIdentifier.digestAlgorithm('SHA-512').digest(input)
+export async function sha512(input) {
+    return AlgorithmIdentifier.digestAlgorithm('SHA-512').digest(input);
 }
-
 /**
  * Computes the MD5 hash of the input data.
  *
@@ -75,10 +69,9 @@ export async function sha512(input: ByteArray): Promise<ByteArray> {
  * const hash = await md5(new Uint8Array([1, 2, 3]))
  * ```
  */
-export async function md5(input: ByteArray): Promise<ByteArray> {
-    return AlgorithmIdentifier.digestAlgorithm('MD5').digest(input)
+export async function md5(input) {
+    return AlgorithmIdentifier.digestAlgorithm('MD5').digest(input);
 }
-
 /**
  * Computes a cryptographic hash of the input data using the specified algorithm.
  *
@@ -92,26 +85,22 @@ export async function md5(input: ByteArray): Promise<ByteArray> {
  * const hash = await hash(data, 'SHA-256')
  * ```
  */
-export async function hash(
-    input: ByteArray,
-    algorithm: 'SHA-256' | 'SHA-384' | 'SHA-512' | 'MD5' | 'SHA-1' = 'SHA-256',
-): Promise<ByteArray> {
+export async function hash(input, algorithm = 'SHA-256') {
     switch (algorithm) {
         case 'SHA-256':
-            return sha256(input)
+            return sha256(input);
         case 'SHA-384':
-            return sha384(input)
+            return sha384(input);
         case 'SHA-512':
-            return sha512(input)
+            return sha512(input);
         case 'MD5':
-            return md5(input)
+            return md5(input);
         case 'SHA-1':
-            return sha1(input)
+            return sha1(input);
         default:
-            throw new Error(`Unsupported hash algorithm: ${algorithm}`)
+            throw new Error(`Unsupported hash algorithm: ${algorithm}`);
     }
 }
-
 /**
  * Generates cryptographically secure random bytes.
  *
@@ -124,11 +113,11 @@ export async function hash(
  * const randomBytes = getRandomBytes(16) // 16 random bytes
  * ```
  */
-export function getRandomBytes(length: number): ByteArray {
-    if (length <= 0) throw new Error('Length must be a positive integer')
-    return AlgorithmIdentifier.randomBytes(length)
+export function getRandomBytes(length) {
+    if (length <= 0)
+        throw new Error('Length must be a positive integer');
+    return AlgorithmIdentifier.randomBytes(length);
 }
-
 /**
  * Encrypts data using AES-128-CBC mode.
  *
@@ -143,25 +132,17 @@ export function getRandomBytes(length: number): ByteArray {
  * const encrypted = await aes128cbcEncrypt(key, plaintext, iv)
  * ```
  */
-export async function aes128cbcEncrypt(
-    key: ByteArray,
-    data: ByteArray,
-    iv: ByteArray = new Uint8Array(16), // Zero IV, as per PDF spec
-): Promise<ByteArray> {
+export async function aes128cbcEncrypt(key, data, iv = new Uint8Array(16)) {
     if (key.length !== 16) {
-        throw new Error(
-            `AES-128 key must be exactly 16 bytes, got ${key.length}`,
-        )
+        throw new Error(`AES-128 key must be exactly 16 bytes, got ${key.length}`);
     }
-
     return AlgorithmIdentifier.contentEncryptionAlgorithm({
         type: 'AES_128_CBC',
         params: {
             nonce: iv,
         },
-    }).encrypt(data, key)
+    }).encrypt(data, key);
 }
-
 /**
  * Decrypts data using AES-128-CBC mode.
  *
@@ -176,28 +157,20 @@ export async function aes128cbcEncrypt(
  * const decrypted = await aes128cbcDecrypt(key, ciphertext, iv)
  * ```
  */
-export async function aes128cbcDecrypt(
-    key: ByteArray,
-    encrypted: ByteArray,
-    iv: ByteArray = new Uint8Array(16), // Zero IV, as per PDF spec
-): Promise<ByteArray> {
+export async function aes128cbcDecrypt(key, encrypted, iv = new Uint8Array(16)) {
     if (key.length !== 16) {
-        throw new Error(
-            `AES-128 key must be exactly 16 bytes, got ${key.length}`,
-        )
+        throw new Error(`AES-128 key must be exactly 16 bytes, got ${key.length}`);
     }
     if (encrypted.length < 16) {
-        throw new Error('Encrypted stream too short — no IV found')
+        throw new Error('Encrypted stream too short — no IV found');
     }
-
     return AlgorithmIdentifier.contentEncryptionAlgorithm({
         type: 'AES_128_CBC',
         params: {
             nonce: iv,
         },
-    }).decrypt(encrypted, key)
+    }).decrypt(encrypted, key);
 }
-
 /**
  * Encrypts data using AES-256-CBC mode.
  *
@@ -211,19 +184,14 @@ export async function aes128cbcDecrypt(
  * const encrypted = await aes256cbcEncrypt(key, plaintext, iv)
  * ```
  */
-export async function aes256cbcEncrypt(
-    fileKey: ByteArray,
-    block: ByteArray,
-    iv: ByteArray = new Uint8Array(16), // Zero IV, as per PDF spec
-): Promise<ByteArray> {
+export async function aes256cbcEncrypt(fileKey, block, iv = new Uint8Array(16)) {
     return AlgorithmIdentifier.contentEncryptionAlgorithm({
         type: 'AES_256_CBC',
         params: {
             nonce: iv,
         },
-    }).encrypt(block, fileKey)
+    }).encrypt(block, fileKey);
 }
-
 /**
  * Decrypts data using AES-256-CBC mode.
  *
@@ -237,19 +205,14 @@ export async function aes256cbcEncrypt(
  * const decrypted = await aes256cbcDecrypt(key, ciphertext, iv)
  * ```
  */
-export async function aes256cbcDecrypt(
-    fileKey: ByteArray,
-    ciphertext: ByteArray,
-    iv: ByteArray = new Uint8Array(16), // Zero IV, as per PDF spec
-): Promise<ByteArray> {
+export async function aes256cbcDecrypt(fileKey, ciphertext, iv = new Uint8Array(16)) {
     return AlgorithmIdentifier.contentEncryptionAlgorithm({
         type: 'AES_256_CBC',
         params: {
             nonce: iv,
         },
-    }).decrypt(ciphertext, fileKey)
+    }).decrypt(ciphertext, fileKey);
 }
-
 /**
  * Encrypts data using AES-256-ECB mode.
  *
@@ -263,22 +226,15 @@ export async function aes256cbcDecrypt(
  * const encrypted = await aes256ecbEncrypt(key, plaintext)
  * ```
  */
-export async function aes256ecbEncrypt(
-    fileKey: ByteArray,
-    data: ByteArray,
-): Promise<ByteArray> {
+export async function aes256ecbEncrypt(fileKey, data) {
     if (fileKey.length !== 32) {
-        throw new Error(
-            `AES-256 key must be exactly 32 bytes, got ${fileKey.length}`,
-        )
+        throw new Error(`AES-256 key must be exactly 32 bytes, got ${fileKey.length}`);
     }
-
     return AlgorithmIdentifier.contentEncryptionAlgorithm({
         type: 'AES_256_ECB',
         params: {},
-    }).encrypt(data, fileKey)
+    }).encrypt(data, fileKey);
 }
-
 /**
  * Decrypts data using AES-256-ECB mode.
  *
@@ -292,22 +248,15 @@ export async function aes256ecbEncrypt(
  * const decrypted = await aes256ecbDecrypt(key, ciphertext)
  * ```
  */
-export async function aes256ecbDecrypt(
-    fileKey: ByteArray,
-    encrypted: ByteArray,
-): Promise<ByteArray> {
+export async function aes256ecbDecrypt(fileKey, encrypted) {
     if (fileKey.length !== 32) {
-        throw new Error(
-            `AES-256 key must be exactly 32 bytes, got ${fileKey.length}`,
-        )
+        throw new Error(`AES-256 key must be exactly 32 bytes, got ${fileKey.length}`);
     }
-
     return AlgorithmIdentifier.contentEncryptionAlgorithm({
         type: 'AES_256_ECB',
         params: {},
-    }).decrypt(encrypted, fileKey)
+    }).decrypt(encrypted, fileKey);
 }
-
 /**
  * Encrypts data using AES-128-CBC mode without PKCS#7 padding.
  *
@@ -321,20 +270,15 @@ export async function aes256ecbDecrypt(
  * const encrypted = await aes128CbcNoPaddingEncrypt(key, data, iv)
  * ```
  */
-export async function aes128CbcNoPaddingEncrypt(
-    key: ByteArray,
-    data: ByteArray,
-    iv: ByteArray,
-): Promise<ByteArray> {
+export async function aes128CbcNoPaddingEncrypt(key, data, iv) {
     return AlgorithmIdentifier.contentEncryptionAlgorithm({
         type: 'AES_128_CBC',
         params: {
             nonce: iv,
             disablePadding: true,
         },
-    }).encrypt(data, key)
+    }).encrypt(data, key);
 }
-
 /**
  * Encrypts data using AES-256-CBC mode without PKCS#7 padding.
  *
@@ -348,20 +292,15 @@ export async function aes128CbcNoPaddingEncrypt(
  * const encrypted = await aes256CbcNoPaddingEncrypt(key, data, iv)
  * ```
  */
-export async function aes256CbcNoPaddingEncrypt(
-    key: ByteArray,
-    data: ByteArray,
-    iv: ByteArray,
-): Promise<ByteArray> {
+export async function aes256CbcNoPaddingEncrypt(key, data, iv) {
     return AlgorithmIdentifier.contentEncryptionAlgorithm({
         type: 'AES_256_CBC',
         params: {
             nonce: iv,
             disablePadding: true,
         },
-    }).encrypt(data, key)
+    }).encrypt(data, key);
 }
-
 /**
  * Decrypts data using AES-256-CBC mode without PKCS#7 padding.
  *
@@ -375,20 +314,15 @@ export async function aes256CbcNoPaddingEncrypt(
  * const decrypted = await aes256CbcNoPaddingDecrypt(key, ciphertext, iv)
  * ```
  */
-export async function aes256CbcNoPaddingDecrypt(
-    key: ByteArray,
-    ciphertext: ByteArray,
-    iv: ByteArray = new Uint8Array(16),
-): Promise<ByteArray> {
+export async function aes256CbcNoPaddingDecrypt(key, ciphertext, iv = new Uint8Array(16)) {
     return AlgorithmIdentifier.contentEncryptionAlgorithm({
         type: 'AES_256_CBC',
         params: {
             nonce: iv,
             disablePadding: true,
         },
-    }).decrypt(ciphertext, key)
+    }).decrypt(ciphertext, key);
 }
-
 /**
  * Compresses data using the DEFLATE algorithm.
  *
@@ -400,14 +334,13 @@ export async function aes256CbcNoPaddingDecrypt(
  * const compressed = deflateData(rawData)
  * ```
  */
-export function deflateData(data: ByteArray): ByteArray {
-    const output = deflate(data)
+export function deflateData(data) {
+    const output = deflate(data);
     if (!output) {
-        return new Uint8Array(0)
+        return new Uint8Array(0);
     }
-    return output
+    return output;
 }
-
 /**
  * Decompresses data using the INFLATE algorithm (reverses DEFLATE).
  *
@@ -420,27 +353,21 @@ export function deflateData(data: ByteArray): ByteArray {
  * const decompressed = inflateData(compressedData)
  * ```
  */
-export function inflateData(data: ByteArray): ByteArray {
+export function inflateData(data) {
     if (data.length === 0) {
-        return new Uint8Array(0) // Return empty array for empty input
+        return new Uint8Array(0); // Return empty array for empty input
     }
-
-    const isWhitespace = (byte: number): boolean => {
-        return byte === 0x20 || byte === 0x09 || byte === 0x0a || byte === 0x0d
-    }
-
-    const inflate = new Inflate()
-    inflate.push(data, true)
-
+    const isWhitespace = (byte) => {
+        return byte === 0x20 || byte === 0x09 || byte === 0x0a || byte === 0x0d;
+    };
+    const inflate = new Inflate();
+    inflate.push(data, true);
     if (inflate.err || !inflate.result) {
         if (isWhitespace(data[data.length - 1])) {
-            data = data.slice(0, -1) // Remove trailing whitespace]
-            return inflateData(data) // Retry inflation after removing whitespace
+            data = data.slice(0, -1); // Remove trailing whitespace]
+            return inflateData(data); // Retry inflation after removing whitespace
         }
-        throw new Error(
-            `Inflate error: ${inflate.err} - ${inflate.msg}. Data hex: ${bytesToHex(data)}`,
-        ) // Log the hex representation of the data for debugging
+        throw new Error(`Inflate error: ${inflate.err} - ${inflate.msg}. Data hex: ${bytesToHex(data)}`); // Log the hex representation of the data for debugging
     }
-
-    return inflate.result as ByteArray
+    return inflate.result;
 }

package/dist/utils/assert.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Asserts that a value is truthy, throwing an error if it is not.
+ *
+ * @param value - The value to check.
+ * @param message - Optional error message to throw if the assertion fails.
+ * @throws Error if the value is falsy.
+ *
+ * @example
+ * ```typescript
+ * assert(user !== null, 'User must be defined')
+ * ```
+ */
+export declare function assert(value: unknown, message?: string): asserts value;
+/**
+ * Conditionally asserts a condition only when a value is defined.
+ * Does nothing if the value is undefined or null.
+ *
+ * @param value - The value to check for definedness.
+ * @param condition - The condition to assert if value is defined.
+ * @param message - Optional error message to throw if the assertion fails.
+ * @throws Error if value is defined and condition is falsy.
+ *
+ * @example
+ * ```typescript
+ * assertIfDefined(user, user?.age >= 18, 'User must be an adult')
+ * ```
+ */
+export declare function assertIfDefined(value: unknown, condition: unknown, message?: string): asserts condition;

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

@@ -10,12 +10,11 @@
  * assert(user !== null, 'User must be defined')
  * ```
  */
-export function assert(value: unknown, message?: string): asserts value {
+export function assert(value, message) {
     if (!value) {
-        throw new Error(message)
+        throw new Error(message);
     }
 }
-
 /**
  * Conditionally asserts a condition only when a value is defined.
  * Does nothing if the value is undefined or null.
@@ -30,13 +29,9 @@ export function assert(value: unknown, message?: string): asserts value {
  * assertIfDefined(user, user?.age >= 18, 'User must be an adult')
  * ```
  */
-export function assertIfDefined(
-    value: unknown,
-    condition: unknown,
-    message?: string,
-): asserts condition {
+export function assertIfDefined(value, condition, message) {
     if (value === undefined || value === null) {
-        return
+        return;
     }
-    assert(condition, message)
+    assert(condition, message);
 }

package/dist/utils/bytesToHex.d.ts

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

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

@@ -1,7 +1,5 @@
-import { ByteArray } from '../types'
-import { bytesToHexBytes } from './bytesToHexBytes'
-import { bytesToString } from './bytesToString'
-
+import { bytesToHexBytes } from './bytesToHexBytes';
+import { bytesToString } from './bytesToString';
 /**
  * Converts a byte array to a hexadecimal string.
  *
@@ -13,6 +11,6 @@ import { bytesToString } from './bytesToString'
  * bytesToHex(new Uint8Array([255, 0, 127])) // Returns 'FF007F'
  * ```
  */
-export function bytesToHex(bytes: ByteArray): string {
-    return bytesToString(bytesToHexBytes(bytes))
+export function bytesToHex(bytes) {
+    return bytesToString(bytesToHexBytes(bytes));
 }

package/dist/utils/bytesToHexBytes.d.ts

@@ -0,0 +1,14 @@
+import { ByteArray } from '../types';
+/**
+ * Converts a byte array to a byte array containing hexadecimal character codes.
+ * Each byte becomes two bytes representing its hex digits.
+ *
+ * @param bytes - The byte array to convert.
+ * @returns A byte array with hexadecimal character codes.
+ *
+ * @example
+ * ```typescript
+ * bytesToHexBytes(new Uint8Array([255])) // Returns bytes for 'FF'
+ * ```
+ */
+export declare function bytesToHexBytes(bytes: ByteArray): ByteArray;

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

@@ -1,7 +1,4 @@
-import { ByteArray } from '../types'
-
-const hexChars = '0123456789ABCDEF'
-
+const hexChars = '0123456789ABCDEF';
 /**
  * Converts a byte array to a byte array containing hexadecimal character codes.
  * Each byte becomes two bytes representing its hex digits.
@@ -14,14 +11,12 @@ const hexChars = '0123456789ABCDEF'
  * bytesToHexBytes(new Uint8Array([255])) // Returns bytes for 'FF'
  * ```
  */
-export function bytesToHexBytes(bytes: ByteArray): ByteArray {
-    const result = new Uint8Array(bytes.length * 2)
-
+export function bytesToHexBytes(bytes) {
+    const result = new Uint8Array(bytes.length * 2);
     for (let i = 0; i < bytes.length; i++) {
-        const byte = bytes[i]
-        result[i * 2] = hexChars.charCodeAt((byte >> 4) & 0x0f)
-        result[i * 2 + 1] = hexChars.charCodeAt(byte & 0x0f)
+        const byte = bytes[i];
+        result[i * 2] = hexChars.charCodeAt((byte >> 4) & 0x0f);
+        result[i * 2 + 1] = hexChars.charCodeAt(byte & 0x0f);
     }
-
-    return result
+    return result;
 }

package/dist/utils/bytesToString.d.ts

@@ -0,0 +1,13 @@
+import { ByteArray } from '../types';
+/**
+ * Converts a byte array to a string using UTF-8 decoding.
+ *
+ * @param bytes - The byte array to decode.
+ * @returns The decoded string.
+ *
+ * @example
+ * ```typescript
+ * bytesToString(new Uint8Array([72, 101, 108, 108, 111])) // Returns 'Hello'
+ * ```
+ */
+export declare function bytesToString(bytes: ByteArray): string;

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

@@ -1,5 +1,3 @@
-import { ByteArray } from '../types'
-
 /**
  * Converts a byte array to a string using UTF-8 decoding.
  *
@@ -11,7 +9,7 @@ import { ByteArray } from '../types'
  * bytesToString(new Uint8Array([72, 101, 108, 108, 111])) // Returns 'Hello'
  * ```
  */
-export function bytesToString(bytes: ByteArray): string {
-    const decoder = new TextDecoder()
-    return decoder.decode(bytes)
+export function bytesToString(bytes) {
+    const decoder = new TextDecoder();
+    return decoder.decode(bytes);
 }

package/dist/utils/concatUint8Arrays.d.ts

@@ -0,0 +1,16 @@
+import { ByteArray } from '../types';
+/**
+ * Concatenates multiple Uint8Array instances into a single ByteArray.
+ *
+ * @param arrays - The arrays to concatenate.
+ * @returns A new ByteArray containing all input arrays concatenated in order.
+ *
+ * @example
+ * ```typescript
+ * const result = concatUint8Arrays(
+ *   new Uint8Array([1, 2]),
+ *   new Uint8Array([3, 4])
+ * ) // Returns Uint8Array([1, 2, 3, 4])
+ * ```
+ */
+export declare function concatUint8Arrays(...arrays: Uint8Array[]): ByteArray;

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

@@ -1,5 +1,3 @@
-import { ByteArray } from '../types'
-
 /**
  * Concatenates multiple Uint8Array instances into a single ByteArray.
  *
@@ -14,13 +12,13 @@ import { ByteArray } from '../types'
  * ) // Returns Uint8Array([1, 2, 3, 4])
  * ```
  */
-export function concatUint8Arrays(...arrays: Uint8Array[]): ByteArray {
-    const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0)
-    const result = new Uint8Array(totalLength)
-    let offset = 0
+export function concatUint8Arrays(...arrays) {
+    const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
     for (const arr of arrays) {
-        result.set(arr, offset)
-        offset += arr.length
+        result.set(arr, offset);
+        offset += arr.length;
     }
-    return result
+    return result;
 }

package/dist/utils/escapeString.d.ts

@@ -0,0 +1,14 @@
+import { ByteArray } from '../types';
+/**
+ * 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 declare function escapeString(bytes: ByteArray | string): ByteArray;