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

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

@@ -1,9 +1,7 @@
-import { DEFAULT_PADDING } from '../constants.js'
-import { md5 } from '../../utils/algos.js'
-import { int32ToLittleEndianBytes } from '../utils.js'
-import { concatUint8Arrays } from '../../utils/concatUint8Arrays.js'
-import { ByteArray } from '../../types.js'
-
+import { DEFAULT_PADDING } from '../constants.js';
+import { md5 } from '../../utils/algos.js';
+import { int32ToLittleEndianBytes } from '../utils.js';
+import { concatUint8Arrays } from '../../utils/concatUint8Arrays.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.
@@ -17,20 +15,17 @@ import { ByteArray } from '../../types.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;
 }
-
 /**
  * Compute the master encryption key for a PDF file.
  *
@@ -41,46 +36,28 @@ export function padPassword(password: ByteArray): ByteArray {
  * @param keyLengthBits Usually 40, 128 or 256
  * @param encryptMetadata Whether /EncryptMetadata is false
  */
-export async function computeMasterKey(
-    password: ByteArray,
-    ownerKey: ByteArray,
-    permissions: number,
-    id0: ByteArray,
-    keyLengthBits: number,
-    encryptMetadata: boolean,
-    revision: number = 3,
-): Promise<ByteArray> {
+export async function computeMasterKey(password, ownerKey, permissions, id0, keyLengthBits, encryptMetadata, revision = 3) {
     if (keyLengthBits % 8 !== 0) {
-        throw new Error(
-            `keyLengthBits must be a multiple of 8, got ${keyLengthBits}`,
-        )
+        throw new Error(`keyLengthBits must be a multiple of 8, got ${keyLengthBits}`);
     }
-
-    const keyLengthBytes = keyLengthBits / 8
-
-    const paddedPassword = padPassword(password)
-    const permissionsBytes = int32ToLittleEndianBytes(permissions)
-
-    const hashInputParts = [paddedPassword, ownerKey, permissionsBytes, id0]
-
+    const keyLengthBytes = keyLengthBits / 8;
+    const paddedPassword = padPassword(password);
+    const permissionsBytes = int32ToLittleEndianBytes(permissions);
+    const hashInputParts = [paddedPassword, ownerKey, permissionsBytes, id0];
     if (keyLengthBits > 40 && !encryptMetadata && revision >= 4) {
-        hashInputParts.push(new Uint8Array([0xff, 0xff, 0xff, 0xff]))
+        hashInputParts.push(new Uint8Array([0xff, 0xff, 0xff, 0xff]));
     }
-
     // Initial MD5 hash
-    let digest = await md5(concatUint8Arrays(...hashInputParts))
-
+    let digest = await md5(concatUint8Arrays(...hashInputParts));
     if (keyLengthBits > 40) {
         // Perform 50 iterations of MD5 rehash
         for (let i = 0; i < 50; i++) {
-            digest = await md5(digest.subarray(0, keyLengthBytes))
+            digest = await md5(digest.subarray(0, keyLengthBytes));
         }
     }
-
     // Truncate to key length
-    return digest.subarray(0, keyLengthBytes)
+    return digest.subarray(0, keyLengthBytes);
 }
-
 /**
  * Derives an object-specific encryption key from the master key.
  * Used to encrypt individual PDF objects with unique keys.
@@ -96,27 +73,19 @@ export async function computeMasterKey(
  * const objectKey = await deriveObjectKey(masterKey, 5, 0)
  * ```
  */
-export async function deriveObjectKey(
-    mkey: ByteArray,
-    objNumber: number,
-    objGeneration: number,
-    useAesSalt: boolean = true,
-): Promise<ByteArray> {
-    const extra = useAesSalt ? 4 : 0 // 4 extra bytes if AES salt
-    const buffer = new Uint8Array(mkey.length + 5 + extra) // <--- make room for salt if needed
-    buffer.set(mkey, 0)
-    buffer[mkey.length + 0] = objNumber & 0xff
-    buffer[mkey.length + 1] = (objNumber >> 8) & 0xff
-    buffer[mkey.length + 2] = (objNumber >> 16) & 0xff
-    buffer[mkey.length + 3] = objGeneration & 0xff
-    buffer[mkey.length + 4] = (objGeneration >> 8) & 0xff
-
+export async function deriveObjectKey(mkey, objNumber, objGeneration, useAesSalt = true) {
+    const extra = useAesSalt ? 4 : 0; // 4 extra bytes if AES salt
+    const buffer = new Uint8Array(mkey.length + 5 + extra); // <--- make room for salt if needed
+    buffer.set(mkey, 0);
+    buffer[mkey.length + 0] = objNumber & 0xff;
+    buffer[mkey.length + 1] = (objNumber >> 8) & 0xff;
+    buffer[mkey.length + 2] = (objNumber >> 16) & 0xff;
+    buffer[mkey.length + 3] = objGeneration & 0xff;
+    buffer[mkey.length + 4] = (objGeneration >> 8) & 0xff;
     if (useAesSalt) {
-        buffer.set([0x73, 0x41, 0x6c, 0x54], mkey.length + 5) // append 'sAlT'
+        buffer.set([0x73, 0x41, 0x6c, 0x54], mkey.length + 5); // append 'sAlT'
     }
-
-    const digest = await md5(buffer)
-
-    const keySize = Math.min(mkey.length + 5, 16)
-    return new Uint8Array(digest.subarray(0, keySize))
+    const digest = await md5(buffer);
+    const keySize = Math.min(mkey.length + 5, 16);
+    return new Uint8Array(digest.subarray(0, keySize));
 }

package/dist/crypto/key-gen/key-gen-aes256.d.ts

@@ -0,0 +1,36 @@
+import { ByteArray } from '../../types.js';
+/**
+ * Generates the /U and /UE values for AES-256 PDF encryption.
+ * These values are used to validate the user password and decrypt the file key.
+ *
+ * @param password - The user password.
+ * @param fileKey - The 32-byte file encryption key.
+ * @returns A promise that resolves to an object containing the 48-byte U and 32-byte UE values.
+ *
+ * @example
+ * ```typescript
+ * const { U, UE } = await generateUandUe(password, fileKey)
+ * ```
+ */
+export declare function generateUandUe(password: ByteArray, fileKey: ByteArray): Promise<{
+    U: ByteArray;
+    UE: ByteArray;
+}>;
+/**
+ * Generates the /O and /OE values for AES-256 PDF encryption.
+ * These values are used to validate the owner password and decrypt the file key.
+ *
+ * @param password - The owner password.
+ * @param U - The 48-byte /U value (required for owner key derivation).
+ * @param fileKey - The 32-byte file encryption key.
+ * @returns A promise that resolves to an object containing the 48-byte O and 32-byte OE values.
+ *
+ * @example
+ * ```typescript
+ * const { O, OE } = await generateOandOe(ownerPassword, U, fileKey)
+ * ```
+ */
+export declare function generateOandOe(password: ByteArray, U: ByteArray, fileKey: ByteArray): Promise<{
+    O: ByteArray;
+    OE: ByteArray;
+}>;

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

@@ -1,8 +1,6 @@
-import { computeAlgorithm2bHash } from '../key-derivation/key-derivation-aes256.js'
-import { getRandomBytes } from '../../utils/algos.js'
-import { aes256CbcNoPaddingEncrypt } from '../../utils/algos.js'
-import { ByteArray } from '../../types.js'
-
+import { computeAlgorithm2bHash } from '../key-derivation/key-derivation-aes256.js';
+import { getRandomBytes } from '../../utils/algos.js';
+import { aes256CbcNoPaddingEncrypt } from '../../utils/algos.js';
 /**
  * Generates the /U and /UE values for AES-256 PDF encryption.
  * These values are used to validate the user password and decrypt the file key.
@@ -16,29 +14,18 @@ import { ByteArray } from '../../types.js'
  * const { U, UE } = await generateUandUe(password, fileKey)
  * ```
  */
-export async function generateUandUe(
-    password: ByteArray,
-    fileKey: ByteArray,
-): Promise<{ U: ByteArray; UE: ByteArray }> {
-    const random = getRandomBytes(16)
-    const userValidationSalt = random.subarray(0, 8)
-    const userKeySalt = random.subarray(8, 16)
-
-    const U = new Uint8Array(48)
-    U.set(await computeAlgorithm2bHash(password, userValidationSalt))
-    U.set(userValidationSalt, 32)
-    U.set(userKeySalt, 40)
-
-    const hash = await computeAlgorithm2bHash(password, userKeySalt)
-    const UE = await aes256CbcNoPaddingEncrypt(
-        hash,
-        fileKey,
-        new Uint8Array(16),
-    )
-
-    return { U, UE }
+export async function generateUandUe(password, fileKey) {
+    const random = getRandomBytes(16);
+    const userValidationSalt = random.subarray(0, 8);
+    const userKeySalt = random.subarray(8, 16);
+    const U = new Uint8Array(48);
+    U.set(await computeAlgorithm2bHash(password, userValidationSalt));
+    U.set(userValidationSalt, 32);
+    U.set(userKeySalt, 40);
+    const hash = await computeAlgorithm2bHash(password, userKeySalt);
+    const UE = await aes256CbcNoPaddingEncrypt(hash, fileKey, new Uint8Array(16));
+    return { U, UE };
 }
-
 /**
  * Generates the /O and /OE values for AES-256 PDF encryption.
  * These values are used to validate the owner password and decrypt the file key.
@@ -53,27 +40,15 @@ export async function generateUandUe(
  * const { O, OE } = await generateOandOe(ownerPassword, U, fileKey)
  * ```
  */
-export async function generateOandOe(
-    password: ByteArray,
-    U: ByteArray,
-    fileKey: ByteArray,
-): Promise<{ O: ByteArray; OE: ByteArray }> {
-    const random = getRandomBytes(16)
-    const ownerValidationSalt = random.subarray(0, 8)
-    const ownerKeySalt = random.subarray(8, 16)
-
-    const O = new Uint8Array(48)
-    O.set(await computeAlgorithm2bHash(password, ownerValidationSalt, U))
-    O.set(ownerValidationSalt, 32)
-    O.set(ownerKeySalt, 40)
-
-    const hash = await computeAlgorithm2bHash(password, ownerKeySalt, U)
-
-    const OE = await aes256CbcNoPaddingEncrypt(
-        hash,
-        fileKey,
-        new Uint8Array(16),
-    )
-
-    return { O, OE }
+export async function generateOandOe(password, U, fileKey) {
+    const random = getRandomBytes(16);
+    const ownerValidationSalt = random.subarray(0, 8);
+    const ownerKeySalt = random.subarray(8, 16);
+    const O = new Uint8Array(48);
+    O.set(await computeAlgorithm2bHash(password, ownerValidationSalt, U));
+    O.set(ownerValidationSalt, 32);
+    O.set(ownerKeySalt, 40);
+    const hash = await computeAlgorithm2bHash(password, ownerKeySalt, U);
+    const OE = await aes256CbcNoPaddingEncrypt(hash, fileKey, new Uint8Array(16));
+    return { O, OE };
 }

package/dist/crypto/key-gen/key-gen-rc4-128.d.ts

@@ -0,0 +1,47 @@
+import { ByteArray } from '../../types';
+/**
+ * Decrypts the user password from the /O value using RC4-128.
+ * Used to recover the user password when the owner password is known.
+ *
+ * @param ownerPw - The owner password.
+ * @param ownerKey - The /O value from the encryption dictionary.
+ * @returns A promise that resolves to the decrypted user password (with padding removed).
+ *
+ * @example
+ * ```typescript
+ * const userPassword = await decryptUserPasswordRc4_128(ownerPw, O)
+ * ```
+ */
+export declare function decryptUserPasswordRc4_128(ownerPw: ByteArray, ownerKey: ByteArray): Promise<ByteArray>;
+/**
+ * Computes the /O value for RC4-128 PDF encryption.
+ * The /O value is used to verify the owner password.
+ *
+ * @param ownerPassword - The owner password.
+ * @param userPassword - The user password.
+ * @returns A promise that resolves to the 32-byte /O value.
+ *
+ * @example
+ * ```typescript
+ * const O = await computeOValueRc4_128(ownerPassword, userPassword)
+ * ```
+ */
+export declare function computeOValueRc4_128(ownerPassword: ByteArray, userPassword: ByteArray): Promise<ByteArray>;
+/**
+ * Computes the /U value for RC4-128 PDF encryption.
+ * The /U value is used to verify the user password.
+ *
+ * @param userPassword - The user password.
+ * @param oValue - The /O value.
+ * @param permissions - The /P value (permissions flags).
+ * @param id - The first element of the /ID array.
+ * @param encryptMetadata - Whether to encrypt metadata.
+ * @param revision - The encryption revision number.
+ * @returns A promise that resolves to the 32-byte /U value.
+ *
+ * @example
+ * ```typescript
+ * const U = await computeUValueRc4_128(userPassword, O, permissions, fileId, true)
+ * ```
+ */
+export declare function computeUValueRc4_128(userPassword: ByteArray, oValue: ByteArray, permissions: number, id: ByteArray, encryptMetadata: boolean, revision?: number): Promise<ByteArray>;

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

@@ -1,11 +1,9 @@
-import { ByteArray } from '../../types'
-import { md5 } from '../../utils/algos'
-import { concatUint8Arrays } from '../../utils/concatUint8Arrays'
-import { rc4 } from '../ciphers/rc4'
-import { DEFAULT_PADDING } from '../constants'
-import { padPassword } from '../key-derivation/key-derivation'
-import { int32ToLittleEndianBytes, removePdfPasswordPadding } from '../utils'
-
+import { md5 } from '../../utils/algos';
+import { concatUint8Arrays } from '../../utils/concatUint8Arrays';
+import { rc4 } from '../ciphers/rc4';
+import { DEFAULT_PADDING } from '../constants';
+import { padPassword } from '../key-derivation/key-derivation';
+import { int32ToLittleEndianBytes, removePdfPasswordPadding } from '../utils';
 /**
  * Encrypts data with RC4 using the provided key.
  *
@@ -13,13 +11,9 @@ import { int32ToLittleEndianBytes, removePdfPasswordPadding } from '../utils'
  * @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-128.
  * Used to recover the user password when the owner password is known.
@@ -33,27 +27,20 @@ async function rc4EncryptWithKey(
  * const userPassword = await decryptUserPasswordRc4_128(ownerPw, O)
  * ```
  */
-export async function decryptUserPasswordRc4_128(
-    ownerPw: ByteArray,
-    ownerKey: ByteArray,
-): Promise<ByteArray> {
-    const ownerPad = padPassword(ownerPw)
-    let digest = await md5(ownerPad)
-
+export async function decryptUserPasswordRc4_128(ownerPw, ownerKey) {
+    const ownerPad = padPassword(ownerPw);
+    let digest = await md5(ownerPad);
     for (let i = 0; i < 50; i++) {
-        digest = await md5(digest)
+        digest = await md5(digest);
     }
-
-    const key = digest.subarray(0, 16)
-    let data = ownerKey
+    const key = digest.subarray(0, 16);
+    let data = ownerKey;
     for (let i = 0; i < 20; i++) {
-        const roundKey = key.map((b) => b ^ i)
-        data = await rc4EncryptWithKey(roundKey, data)
+        const roundKey = key.map((b) => b ^ i);
+        data = await rc4EncryptWithKey(roundKey, data);
     }
-
-    return removePdfPasswordPadding(data)
+    return removePdfPasswordPadding(data);
 }
-
 /**
  * Computes the /O value for RC4-128 PDF encryption.
  * The /O value is used to verify the owner password.
@@ -67,30 +54,21 @@ export async function decryptUserPasswordRc4_128(
  * const O = await computeOValueRc4_128(ownerPassword, userPassword)
  * ```
  */
-export async function computeOValueRc4_128(
-    ownerPassword: ByteArray,
-    userPassword: ByteArray,
-): Promise<ByteArray> {
-    const oPad = padPassword(ownerPassword)
-
-    let digest = await md5(oPad)
+export async function computeOValueRc4_128(ownerPassword, userPassword) {
+    const oPad = padPassword(ownerPassword);
+    let digest = await md5(oPad);
     for (let i = 0; i < 50; i++) {
-        digest = await md5(digest)
+        digest = await md5(digest);
     }
-
-    const key = digest.subarray(0, 16)
-
-    const uPad = padPassword(userPassword)
-    let data = await rc4EncryptWithKey(key, uPad)
-
+    const key = digest.subarray(0, 16);
+    const uPad = padPassword(userPassword);
+    let data = await rc4EncryptWithKey(key, uPad);
     for (let i = 1; i <= 19; i++) {
-        const roundKey = key.map((b) => b ^ i)
-        data = await rc4EncryptWithKey(roundKey, data)
+        const roundKey = key.map((b) => b ^ i);
+        data = await rc4EncryptWithKey(roundKey, data);
     }
-
-    return data
+    return data;
 }
-
 /**
  * Computes the 128-bit encryption key for RC4-128 PDF encryption.
  *
@@ -102,36 +80,17 @@ export async function computeOValueRc4_128(
  * @param revision - The encryption revision number.
  * @returns A promise that resolves to the 16-byte encryption key.
  */
-async function computeEncryptionKeyRc4_128(
-    userPad: ByteArray,
-    oValue: ByteArray,
-    permissions: number,
-    id: ByteArray,
-    encryptMetadata: boolean,
-    revision: number = 3,
-): Promise<ByteArray> {
-    const perms = int32ToLittleEndianBytes(permissions)
-
-    let digest = await md5(
-        concatUint8Arrays(
-            userPad,
-            oValue,
-            perms,
-            id,
-            revision >= 4 && !encryptMetadata
-                ? new Uint8Array([0xff, 0xff, 0xff, 0xff])
-                : new Uint8Array(),
-        ),
-    )
-
+async function computeEncryptionKeyRc4_128(userPad, oValue, permissions, id, encryptMetadata, revision = 3) {
+    const perms = int32ToLittleEndianBytes(permissions);
+    let digest = await md5(concatUint8Arrays(userPad, oValue, perms, id, revision >= 4 && !encryptMetadata
+        ? new Uint8Array([0xff, 0xff, 0xff, 0xff])
+        : new Uint8Array()));
     // 50 iterations
     for (let i = 0; i < 50; i++) {
-        digest = await md5(digest)
+        digest = await md5(digest);
     }
-
-    return digest.subarray(0, 16) // RC4-128
+    return digest.subarray(0, 16); // RC4-128
 }
-
 /**
  * Computes the /U value for RC4-128 PDF encryption.
  * The /U value is used to verify the user password.
@@ -149,42 +108,22 @@ async function computeEncryptionKeyRc4_128(
  * const U = await computeUValueRc4_128(userPassword, O, permissions, fileId, true)
  * ```
  */
-export async function computeUValueRc4_128(
-    userPassword: ByteArray,
-    oValue: ByteArray,
-    permissions: number,
-    id: ByteArray,
-    encryptMetadata: boolean,
-    revision?: number,
-): Promise<ByteArray> {
-    const userPad = padPassword(userPassword)
-
+export async function computeUValueRc4_128(userPassword, oValue, permissions, id, encryptMetadata, revision) {
+    const userPad = padPassword(userPassword);
     // Step 1: Compute encryption key
-    const encryptionKey = await computeEncryptionKeyRc4_128(
-        userPad,
-        oValue,
-        permissions,
-        id,
-        encryptMetadata,
-        revision,
-    )
-
+    const encryptionKey = await computeEncryptionKeyRc4_128(userPad, oValue, permissions, id, encryptMetadata, revision);
     // Step 2 & 3: MD5 of padding + file ID
-    const hash = await md5(concatUint8Arrays(DEFAULT_PADDING, id)) // 16 bytes
-
+    const hash = await md5(concatUint8Arrays(DEFAULT_PADDING, id)); // 16 bytes
     // Step 4: First RC4 encrypt with base key
-    let data = await rc4EncryptWithKey(encryptionKey, hash)
-
+    let data = await rc4EncryptWithKey(encryptionKey, hash);
     // Step 5: 19 more rounds of RC4 with key XOR i
     for (let i = 1; i <= 19; i++) {
-        const roundKey = encryptionKey.map((b) => b ^ i)
-        data = await rc4EncryptWithKey(roundKey, data)
+        const roundKey = encryptionKey.map((b) => b ^ i);
+        data = await rc4EncryptWithKey(roundKey, data);
     }
-
     // Step 6: Append 16 more bytes (usually same padding again, or random)
-    const result = new Uint8Array(32)
-    result.set(data, 0)
-    result.set(DEFAULT_PADDING.subarray(0, 16), 16)
-
-    return result
+    const result = new Uint8Array(32);
+    result.set(data, 0);
+    result.set(DEFAULT_PADDING.subarray(0, 16), 16);
+    return result;
 }

package/dist/crypto/key-gen/key-gen-rc4-40.d.ts

@@ -0,0 +1,60 @@
+import { ByteArray } from '../../types.js';
+/**
+ * Decrypts the user password from the /O value using RC4-40.
+ * Used to recover the user password when the owner password is known.
+ *
+ * @param ownerPw - The owner password.
+ * @param ownerKey - The /O value from the encryption dictionary.
+ * @returns A promise that resolves to the decrypted user password (with padding removed).
+ *
+ * @example
+ * ```typescript
+ * const userPassword = await decryptUserPasswordRc4_40(ownerPw, O)
+ * ```
+ */
+export declare function decryptUserPasswordRc4_40(ownerPw: ByteArray, ownerKey: ByteArray): Promise<ByteArray>;
+/**
+ * Computes the /O value for RC4-40 PDF encryption.
+ * The /O value is used to verify the owner password.
+ *
+ * @param ownerPw - The owner password.
+ * @param userPw - The user password.
+ * @returns A promise that resolves to the 32-byte /O value.
+ *
+ * @example
+ * ```typescript
+ * const O = await computeORc4_40(ownerPassword, userPassword)
+ * ```
+ */
+export declare function computeORc4_40(ownerPw: ByteArray, userPw: ByteArray): Promise<ByteArray>;
+/**
+ * Computes the 40-bit encryption key for RC4-40 PDF encryption.
+ *
+ * @param userPw - The user password.
+ * @param oValue - The /O value.
+ * @param permissions - The /P value (permissions flags).
+ * @param fileId - The first element of the /ID array.
+ * @returns A promise that resolves to the 5-byte (40-bit) encryption key.
+ *
+ * @example
+ * ```typescript
+ * const key = await computeEncryptionKeyRc4_40(userPw, O, permissions, fileId)
+ * ```
+ */
+export declare function computeEncryptionKeyRc4_40(userPw: ByteArray, oValue: ByteArray, permissions: number, fileId: ByteArray): Promise<ByteArray>;
+/**
+ * Computes the /U value for RC4-40 PDF encryption.
+ * The /U value is used to verify the user password.
+ *
+ * @param userPw - The user password.
+ * @param oValue - The /O value.
+ * @param permissions - The /P value (permissions flags).
+ * @param fileId - The first element of the /ID array.
+ * @returns A promise that resolves to the 32-byte /U value.
+ *
+ * @example
+ * ```typescript
+ * const U = await computeURc4_40(userPassword, O, permissions, fileId)
+ * ```
+ */
+export declare function computeURc4_40(userPw: ByteArray, oValue: ByteArray, permissions: number, fileId: ByteArray): Promise<ByteArray>;