pdf-lite 1.0.1-alpha.2 → 1.0.1-alpha.3

package/{packages/pdf-lite/src/crypto/key-gen/key-gen-rc4-40.ts → dist/crypto/key-gen/key-gen-rc4-40.js}

@@ -1,11 +1,9 @@
-import { padPassword } from '../key-derivation/key-derivation.js'
-import { rc4 } from '../ciphers/rc4.js'
-import { DEFAULT_PADDING } from '../constants.js'
-import { int32ToLittleEndianBytes, removePdfPasswordPadding } from '../utils.js'
-import { md5 } from '../../utils/algos.js'
-import { concatUint8Arrays } from '../../utils/concatUint8Arrays.js'
-import { ByteArray } from '../../types.js'
-
+import { padPassword } from '../key-derivation/key-derivation.js';
+import { rc4 } from '../ciphers/rc4.js';
+import { DEFAULT_PADDING } from '../constants.js';
+import { int32ToLittleEndianBytes, removePdfPasswordPadding } from '../utils.js';
+import { md5 } from '../../utils/algos.js';
+import { concatUint8Arrays } from '../../utils/concatUint8Arrays.js';
 /**
  * Encrypts data with RC4 using the provided key.
  *
@@ -13,13 +11,9 @@ import { ByteArray } from '../../types.js'
  * @param data - The data to encrypt.
  * @returns A promise that resolves to the encrypted data.
  */
-async function rc4EncryptWithKey(
-    key: ByteArray,
-    data: ByteArray,
-): Promise<ByteArray> {
-    return await rc4(key).encrypt(data)
+async function rc4EncryptWithKey(key, data) {
+    return await rc4(key).encrypt(data);
 }
-
 /**
  * Decrypts the user password from the /O value using RC4-40.
  * Used to recover the user password when the owner password is known.
@@ -33,19 +27,12 @@ async function rc4EncryptWithKey(
  * const userPassword = await decryptUserPasswordRc4_40(ownerPw, O)
  * ```
  */
-export async function decryptUserPasswordRc4_40(
-    ownerPw: ByteArray,
-    ownerKey: ByteArray,
-): Promise<ByteArray> {
-    const ownerPad = padPassword(ownerPw)
-    const digest = await md5(ownerPad)
-    const rc4Key = digest.slice(0, 5) // 40-bit key
-
-    return await removePdfPasswordPadding(
-        await rc4EncryptWithKey(rc4Key, ownerKey),
-    )
+export async function decryptUserPasswordRc4_40(ownerPw, ownerKey) {
+    const ownerPad = padPassword(ownerPw);
+    const digest = await md5(ownerPad);
+    const rc4Key = digest.slice(0, 5); // 40-bit key
+    return await removePdfPasswordPadding(await rc4EncryptWithKey(rc4Key, ownerKey));
 }
-
 /**
  * Computes the /O value for RC4-40 PDF encryption.
  * The /O value is used to verify the owner password.
@@ -59,17 +46,12 @@ export async function decryptUserPasswordRc4_40(
  * const O = await computeORc4_40(ownerPassword, userPassword)
  * ```
  */
-export async function computeORc4_40(
-    ownerPw: ByteArray,
-    userPw: ByteArray,
-): Promise<ByteArray> {
-    const ownerPad = padPassword(ownerPw)
-    const digest = await md5(ownerPad)
-    const rc4Key = digest.slice(0, 5) // 40-bit key
-
-    return await rc4EncryptWithKey(rc4Key, padPassword(userPw))
+export async function computeORc4_40(ownerPw, userPw) {
+    const ownerPad = padPassword(ownerPw);
+    const digest = await md5(ownerPad);
+    const rc4Key = digest.slice(0, 5); // 40-bit key
+    return await rc4EncryptWithKey(rc4Key, padPassword(userPw));
 }
-
 /**
  * Computes the 40-bit encryption key for RC4-40 PDF encryption.
  *
@@ -84,20 +66,12 @@ export async function computeORc4_40(
  * const key = await computeEncryptionKeyRc4_40(userPw, O, permissions, fileId)
  * ```
  */
-export async function computeEncryptionKeyRc4_40(
-    userPw: ByteArray,
-    oValue: ByteArray,
-    permissions: number,
-    fileId: ByteArray,
-): Promise<ByteArray> {
-    const userPad = padPassword(userPw)
-    const permissionsLE = int32ToLittleEndianBytes(permissions)
-    const digest = await md5(
-        concatUint8Arrays(userPad, oValue, permissionsLE, fileId),
-    )
-    return digest.slice(0, 5) // 40-bit key
+export async function computeEncryptionKeyRc4_40(userPw, oValue, permissions, fileId) {
+    const userPad = padPassword(userPw);
+    const permissionsLE = int32ToLittleEndianBytes(permissions);
+    const digest = await md5(concatUint8Arrays(userPad, oValue, permissionsLE, fileId));
+    return digest.slice(0, 5); // 40-bit key
 }
-
 /**
  * Computes the /U value for RC4-40 PDF encryption.
  * The /U value is used to verify the user password.
@@ -113,17 +87,7 @@ export async function computeEncryptionKeyRc4_40(
  * const U = await computeURc4_40(userPassword, O, permissions, fileId)
  * ```
  */
-export async function computeURc4_40(
-    userPw: ByteArray,
-    oValue: ByteArray,
-    permissions: number,
-    fileId: ByteArray,
-): Promise<ByteArray> {
-    const encryptionKey = await computeEncryptionKeyRc4_40(
-        userPw,
-        oValue,
-        permissions,
-        fileId,
-    )
-    return await rc4EncryptWithKey(encryptionKey, DEFAULT_PADDING)
+export async function computeURc4_40(userPw, oValue, permissions, fileId) {
+    const encryptionKey = await computeEncryptionKeyRc4_40(userPw, oValue, permissions, fileId);
+    return await rc4EncryptWithKey(encryptionKey, DEFAULT_PADDING);
 }

package/dist/crypto/types.d.ts

@@ -0,0 +1,5 @@
+import { ByteArray } from '../types';
+export interface Cipher {
+    encrypt(data: ByteArray): Promise<ByteArray>;
+    decrypt(data: ByteArray): Promise<ByteArray>;
+}

package/dist/crypto/types.js

@@ -0,0 +1 @@
+export {};

package/dist/crypto/utils.d.ts

@@ -0,0 +1,40 @@
+import { ByteArray } from '../types.js';
+/**
+ * Pads a password to exactly 32 bytes using the PDF standard padding.
+ * If the password is shorter than 32 bytes, it is padded with bytes from DEFAULT_PADDING.
+ * If the password is 32 bytes or longer, only the first 32 bytes are used.
+ *
+ * @param password - The password to pad.
+ * @returns A 32-byte padded password.
+ *
+ * @example
+ * ```typescript
+ * const padded = padPassword(new Uint8Array([1, 2, 3])) // Returns 32-byte array
+ * ```
+ */
+export declare function padPassword(password: ByteArray): ByteArray;
+/**
+ * Converts a 32-bit integer to a 4-byte little-endian byte array.
+ *
+ * @param value - The 32-bit integer to convert.
+ * @returns A 4-byte array in little-endian order.
+ *
+ * @example
+ * ```typescript
+ * int32ToLittleEndianBytes(0x12345678) // Returns [0x78, 0x56, 0x34, 0x12]
+ * ```
+ */
+export declare function int32ToLittleEndianBytes(value: number): ByteArray;
+/**
+ * Removes PDF standard password padding from a buffer.
+ * Searches from the end of the buffer for the padding pattern and removes it.
+ *
+ * @param buffer - The buffer with potential password padding.
+ * @returns The buffer with padding removed.
+ *
+ * @example
+ * ```typescript
+ * const unpadded = removePdfPasswordPadding(paddedPassword)
+ * ```
+ */
+export declare function removePdfPasswordPadding(buffer: ByteArray): Uint8Array<ArrayBuffer>;

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

@@ -1,6 +1,4 @@
-import { ByteArray } from '../types.js'
-import { DEFAULT_PADDING } from './constants.js'
-
+import { DEFAULT_PADDING } from './constants.js';
 /**
  * Pads a password to exactly 32 bytes using the PDF standard padding.
  * If the password is shorter than 32 bytes, it is padded with bytes from DEFAULT_PADDING.
@@ -14,20 +12,17 @@ import { DEFAULT_PADDING } from './constants.js'
  * const padded = padPassword(new Uint8Array([1, 2, 3])) // Returns 32-byte array
  * ```
  */
-export function padPassword(password: ByteArray): ByteArray {
-    const padded = new Uint8Array(32)
+export function padPassword(password) {
+    const padded = new Uint8Array(32);
     if (password.length >= 32) {
-        padded.set(password.subarray(0, 32))
-    } else {
-        padded.set(password)
-        padded.set(
-            DEFAULT_PADDING.subarray(0, 32 - password.length),
-            password.length,
-        )
+        padded.set(password.subarray(0, 32));
     }
-    return padded
+    else {
+        padded.set(password);
+        padded.set(DEFAULT_PADDING.subarray(0, 32 - password.length), password.length);
+    }
+    return padded;
 }
-
 /**
  * Converts a 32-bit integer to a 4-byte little-endian byte array.
  *
@@ -39,15 +34,14 @@ export function padPassword(password: ByteArray): ByteArray {
  * int32ToLittleEndianBytes(0x12345678) // Returns [0x78, 0x56, 0x34, 0x12]
  * ```
  */
-export function int32ToLittleEndianBytes(value: number): ByteArray {
-    const bytes = new Uint8Array(4)
-    bytes[0] = value & 0xff
-    bytes[1] = (value >> 8) & 0xff
-    bytes[2] = (value >> 16) & 0xff
-    bytes[3] = (value >> 24) & 0xff
-    return bytes
+export function int32ToLittleEndianBytes(value) {
+    const bytes = new Uint8Array(4);
+    bytes[0] = value & 0xff;
+    bytes[1] = (value >> 8) & 0xff;
+    bytes[2] = (value >> 16) & 0xff;
+    bytes[3] = (value >> 24) & 0xff;
+    return bytes;
 }
-
 /**
  * Removes PDF standard password padding from a buffer.
  * Searches from the end of the buffer for the padding pattern and removes it.
@@ -60,22 +54,19 @@ export function int32ToLittleEndianBytes(value: number): ByteArray {
  * const unpadded = removePdfPasswordPadding(paddedPassword)
  * ```
  */
-export function removePdfPasswordPadding(buffer: ByteArray) {
-    const padding = DEFAULT_PADDING
-    const len = buffer.length
-
+export function removePdfPasswordPadding(buffer) {
+    const padding = DEFAULT_PADDING;
+    const len = buffer.length;
     // Find where padding starts
-    let end = len
+    let end = len;
     for (let i = len - 1; i >= 0; i--) {
-        const slice = buffer.slice(i)
-        const paddingStart = padding.slice(0, slice.length)
-        if (
-            slice.length === paddingStart.length &&
-            slice.every((v, j) => v === paddingStart[j])
-        ) {
-            end = i
-            break
+        const slice = buffer.slice(i);
+        const paddingStart = padding.slice(0, slice.length);
+        if (slice.length === paddingStart.length &&
+            slice.every((v, j) => v === paddingStart[j])) {
+            end = i;
+            break;
         }
     }
-    return buffer.slice(0, end)
+    return buffer.slice(0, end);
 }

package/dist/filters/ascii85.d.ts

@@ -0,0 +1,16 @@
+import { PdfFilter } from './types.js';
+/**
+ * Creates an ASCII85 filter for encoding and decoding PDF stream data.
+ * ASCII85 (also known as Base85) encodes binary data into ASCII characters,
+ * resulting in a 25% expansion compared to the original data.
+ *
+ * @returns A PdfFilter object with encode and decode methods.
+ *
+ * @example
+ * ```typescript
+ * const filter = ascii85()
+ * const encoded = filter.encode(binaryData)
+ * const decoded = filter.decode(encoded)
+ * ```
+ */
+export declare function ascii85(): PdfFilter;

package/{packages/pdf-lite/src/filters/ascii85.ts → dist/filters/ascii85.js}

@@ -1,7 +1,4 @@
-import { ByteArray } from '../types.js'
-import { stringToBytes } from '../utils/stringToBytes.js'
-import { PdfFilter } from './types.js'
-
+import { stringToBytes } from '../utils/stringToBytes.js';
 /**
  * Creates an ASCII85 filter for encoding and decoding PDF stream data.
  * ASCII85 (also known as Base85) encodes binary data into ASCII characters,
@@ -16,7 +13,7 @@ import { PdfFilter } from './types.js'
  * const decoded = filter.decode(encoded)
  * ```
  */
-export function ascii85(): PdfFilter {
+export function ascii85() {
     return {
         /**
          * Encodes binary data to ASCII85 format.
@@ -24,44 +21,37 @@ export function ascii85(): PdfFilter {
          * @param data - The binary data to encode.
          * @returns The ASCII85 encoded data as a byte array.
          */
-        encode: (data: ByteArray): ByteArray => {
-            let result = ''
-            let i = 0
-
+        encode: (data) => {
+            let result = '';
+            let i = 0;
             while (i < data.length) {
                 // Read up to 4 bytes
-                const chunk = new Array(4).fill(0)
-                let chunkLen = 0
+                const chunk = new Array(4).fill(0);
+                let chunkLen = 0;
                 for (; chunkLen < 4 && i < data.length; chunkLen++, i++) {
-                    chunk[chunkLen] = data[i]
+                    chunk[chunkLen] = data[i];
                 }
-
                 // Check for special case: 4 zero bytes encode to 'z'
                 if (chunkLen === 4 && chunk.every((b) => b === 0)) {
-                    result += 'z'
-                    continue
+                    result += 'z';
+                    continue;
                 }
-
                 // Convert 4 bytes to 32-bit value
-                let value = 0
+                let value = 0;
                 for (let j = 0; j < 4; j++) {
-                    value = (value << 8) | chunk[j]
+                    value = (value << 8) | chunk[j];
                 }
-
                 // Convert to base 85
-                const encoded = new Array(5)
+                const encoded = new Array(5);
                 for (let j = 4; j >= 0; j--) {
-                    encoded[j] = String.fromCharCode((value % 85) + 33)
-                    value = Math.floor(value / 85)
+                    encoded[j] = String.fromCharCode((value % 85) + 33);
+                    value = Math.floor(value / 85);
                 }
-
                 // For incomplete groups, only output chunkLen + 1 characters
-                result += encoded.slice(0, chunkLen + 1).join('')
+                result += encoded.slice(0, chunkLen + 1).join('');
             }
-
-            return stringToBytes(result)
+            return stringToBytes(result);
         },
-
         /**
          * Decodes ASCII85 encoded data back to binary format.
          *
@@ -69,60 +59,46 @@ export function ascii85(): PdfFilter {
          * @returns The decoded binary data as a byte array.
          * @throws Error if invalid ASCII85 characters are encountered.
          */
-        decode: (data: ByteArray): ByteArray => {
-            let str = new TextDecoder().decode(data)
-
+        decode: (data) => {
+            let str = new TextDecoder().decode(data);
             // Remove delimiters if present
-            str = str.replace(/^<~/, '').replace(/~>$/, '')
-
+            str = str.replace(/^<~/, '').replace(/~>$/, '');
             // Remove whitespace
-            str = str.replace(/\s/g, '')
-
-            const out: number[] = []
-            let i = 0
-
+            str = str.replace(/\s/g, '');
+            const out = [];
+            let i = 0;
             while (i < str.length) {
-                const char = str[i]
-
+                const char = str[i];
                 // Handle special 'z' case (represents 4 zero bytes)
                 if (char === 'z') {
-                    out.push(0, 0, 0, 0)
-                    i++
-                    continue
+                    out.push(0, 0, 0, 0);
+                    i++;
+                    continue;
                 }
-
                 // Read up to 5 characters
-                const chunk = new Array(5).fill(84) // Fill with 'u' (84 + 33 = 117 = 'u')
-                let chunkLen = 0
-
-                for (
-                    ;
-                    chunkLen < 5 && i < str.length && str[i] !== 'z';
-                    chunkLen++, i++
-                ) {
-                    const code = str.charCodeAt(i) - 33
+                const chunk = new Array(5).fill(84); // Fill with 'u' (84 + 33 = 117 = 'u')
+                let chunkLen = 0;
+                for (; chunkLen < 5 && i < str.length && str[i] !== 'z'; chunkLen++, i++) {
+                    const code = str.charCodeAt(i) - 33;
                     if (code < 0 || code > 84) {
-                        throw new Error(`Invalid ASCII85 character: ${str[i]}`)
+                        throw new Error(`Invalid ASCII85 character: ${str[i]}`);
                     }
-                    chunk[chunkLen] = code
+                    chunk[chunkLen] = code;
                 }
-
-                if (chunkLen === 0) break
-
+                if (chunkLen === 0)
+                    break;
                 // Convert from base 85 to 32-bit value
-                let value = 0
+                let value = 0;
                 for (let j = 0; j < 5; j++) {
-                    value = value * 85 + chunk[j]
+                    value = value * 85 + chunk[j];
                 }
-
                 // Extract bytes (but only the ones we should have based on input length)
-                const bytesToOutput = Math.min(4, chunkLen - 1)
+                const bytesToOutput = Math.min(4, chunkLen - 1);
                 for (let j = 3; j >= 4 - bytesToOutput; j--) {
-                    out.push((value >> (j * 8)) & 0xff)
+                    out.push((value >> (j * 8)) & 0xff);
                 }
             }
-
-            return new Uint8Array(out)
+            return new Uint8Array(out);
         },
-    }
+    };
 }

package/dist/filters/asciihex.d.ts

@@ -0,0 +1,16 @@
+import { PdfFilter } from './types';
+/**
+ * Creates an ASCIIHex filter for encoding and decoding PDF stream data.
+ * ASCIIHex encodes binary data as pairs of hexadecimal digits,
+ * resulting in a 100% expansion compared to the original data.
+ *
+ * @returns A PdfFilter object with encode and decode methods.
+ *
+ * @example
+ * ```typescript
+ * const filter = asciiHex()
+ * const encoded = filter.encode(binaryData)
+ * const decoded = filter.decode(encoded)
+ * ```
+ */
+export declare function asciiHex(): PdfFilter;

package/{packages/pdf-lite/src/filters/asciihex.ts → dist/filters/asciihex.js}

@@ -1,8 +1,5 @@
-import { ByteArray } from '../types'
-import { bytesToString } from '../utils/bytesToString'
-import { stringToBytes } from '../utils/stringToBytes'
-import { PdfFilter } from './types'
-
+import { bytesToString } from '../utils/bytesToString';
+import { stringToBytes } from '../utils/stringToBytes';
 /**
  * Creates an ASCIIHex filter for encoding and decoding PDF stream data.
  * ASCIIHex encodes binary data as pairs of hexadecimal digits,
@@ -17,7 +14,7 @@ import { PdfFilter } from './types'
  * const decoded = filter.decode(encoded)
  * ```
  */
-export function asciiHex(): PdfFilter {
+export function asciiHex() {
     return {
         /**
          * Encodes binary data to ASCIIHex format.
@@ -26,13 +23,13 @@ export function asciiHex(): PdfFilter {
          * @param data - The binary data to encode.
          * @returns The ASCIIHex encoded data as a byte array.
          */
-        encode: (data: ByteArray) => {
-            let out = ''
+        encode: (data) => {
+            let out = '';
             for (let i = 0; i < data.length; i++) {
-                out += data[i].toString(16).padStart(2, '0').toUpperCase()
+                out += data[i].toString(16).padStart(2, '0').toUpperCase();
             }
-            out += '>'
-            return stringToBytes(out)
+            out += '>';
+            return stringToBytes(out);
         },
         /**
          * Decodes ASCIIHex encoded data back to binary format.
@@ -41,15 +38,17 @@ export function asciiHex(): PdfFilter {
          * @param data - The ASCIIHex encoded data.
          * @returns The decoded binary data as a byte array.
          */
-        decode: (data: ByteArray) => {
-            let hex = bytesToString(data).replace(/\s+/g, '')
-            if (hex.endsWith('>')) hex = hex.slice(0, -1)
-            if (hex.length % 2 !== 0) hex += '0'
-            const out = new Uint8Array(hex.length / 2)
+        decode: (data) => {
+            let hex = bytesToString(data).replace(/\s+/g, '');
+            if (hex.endsWith('>'))
+                hex = hex.slice(0, -1);
+            if (hex.length % 2 !== 0)
+                hex += '0';
+            const out = new Uint8Array(hex.length / 2);
             for (let i = 0; i < hex.length; i += 2) {
-                out[i / 2] = parseInt(hex.substr(i, 2), 16)
+                out[i / 2] = parseInt(hex.substr(i, 2), 16);
             }
-            return out
+            return out;
         },
-    }
+    };
 }

package/dist/filters/flate.d.ts

@@ -0,0 +1,15 @@
+import { PdfFilter } from './types.js';
+/**
+ * Creates a Flate filter for compressing and decompressing PDF stream data.
+ * Uses the DEFLATE compression algorithm (same as zlib/gzip).
+ *
+ * @returns A PdfFilter object with encode and decode methods.
+ *
+ * @example
+ * ```typescript
+ * const filter = flate()
+ * const compressed = filter.encode(rawData)
+ * const decompressed = filter.decode(compressed)
+ * ```
+ */
+export declare function flate(): PdfFilter;

package/{packages/pdf-lite/src/filters/flate.ts → dist/filters/flate.js}

@@ -1,7 +1,4 @@
-import { ByteArray } from '../types.js'
-import { inflateData, deflateData } from '../utils/algos.js'
-import { PdfFilter } from './types.js'
-
+import { inflateData, deflateData } from '../utils/algos.js';
 /**
  * Creates a Flate filter for compressing and decompressing PDF stream data.
  * Uses the DEFLATE compression algorithm (same as zlib/gzip).
@@ -15,7 +12,7 @@ import { PdfFilter } from './types.js'
  * const decompressed = filter.decode(compressed)
  * ```
  */
-export function flate(): PdfFilter {
+export function flate() {
     return {
         /**
          * Compresses data using the DEFLATE algorithm.
@@ -23,8 +20,8 @@ export function flate(): PdfFilter {
          * @param data - The data to compress.
          * @returns The compressed data as a byte array.
          */
-        encode: (data: ByteArray) => {
-            return deflateData(data)
+        encode: (data) => {
+            return deflateData(data);
         },
         /**
          * Decompresses DEFLATE-compressed data.
@@ -32,8 +29,8 @@ export function flate(): PdfFilter {
          * @param data - The compressed data to decompress.
          * @returns The decompressed data as a byte array.
          */
-        decode: (data: ByteArray) => {
-            return inflateData(data)
+        decode: (data) => {
+            return inflateData(data);
         },
-    }
+    };
 }

package/dist/filters/lzw.d.ts

@@ -0,0 +1,16 @@
+import { PdfFilter } from './types';
+/**
+ * Creates an LZW filter for encoding and decoding PDF stream data.
+ * LZW (Lempel-Ziv-Welch) is a lossless compression algorithm.
+ * This is a minimal implementation for PDF (12-bit, no early change, no predictor).
+ *
+ * @returns A PdfFilter object with encode and decode methods.
+ *
+ * @example
+ * ```typescript
+ * const filter = lzw()
+ * const compressed = filter.encode(rawData)
+ * const decompressed = filter.decode(compressed)
+ * ```
+ */
+export declare function lzw(): PdfFilter;