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

package/dist/signing/signer.js

@@ -0,0 +1,92 @@
+import { PdfCommentToken } from '../core/tokens/comment-token';
+import { PdfHexadecimalToken } from '../core/tokens/hexadecimal-token';
+import { PdfNameToken } from '../core/tokens/name-token';
+import { concatUint8Arrays } from '../utils/concatUint8Arrays';
+import { PdfDocumentSecurityStoreObject } from './document-security-store';
+import { PdfSignatureObject } from './signatures';
+/**
+ * Handles digital signing operations for PDF documents.
+ * Processes signature objects and optionally stores revocation information in the DSS.
+ *
+ * @example
+ * ```typescript
+ * const signer = new PdfSigner()
+ * const signedDoc = await signer.sign(document)
+ * ```
+ */
+export class PdfSigner {
+    /** Whether to use the Document Security Store for revocation information. */
+    useDocumentSecurityStore = true;
+    /**
+     * Signs all signature objects in the document.
+     * Computes byte ranges, generates signatures, and optionally adds revocation info to DSS.
+     *
+     * @param document - The PDF document to sign.
+     * @returns The signed document.
+     */
+    async sign(document) {
+        const signatures = [
+            ...document.objects.filter((x) => x instanceof PdfSignatureObject),
+        ];
+        const dss = this.useDocumentSecurityStore
+            ? (document.objects.find((x) => x instanceof PdfDocumentSecurityStoreObject) ?? new PdfDocumentSecurityStoreObject(document))
+            : undefined;
+        for (let i = 0; i < signatures.length; i++) {
+            const signature = signatures[i];
+            const tokens = document.tokensWithObjects();
+            const signableTokens = [];
+            let contentsOffset = 0;
+            let contentsLength = 0;
+            let byteCount = 0;
+            let seen = 0;
+            for (let j = 0; j < tokens.length; j++) {
+                let { token, object } = tokens[j];
+                if (!(object instanceof PdfSignatureObject)) {
+                    signableTokens.push(token);
+                }
+                else if (!(token instanceof PdfNameToken) ||
+                    token.name !== 'Contents') {
+                    signableTokens.push(token);
+                }
+                else {
+                    while (token instanceof PdfHexadecimalToken === false) {
+                        byteCount += token.byteLength;
+                        token = tokens[++j].token;
+                    }
+                    const contentsToken = token;
+                    const tokenStr = contentsToken.toString();
+                    const start = tokenStr.indexOf('<');
+                    contentsOffset = byteCount + start;
+                    contentsLength = tokenStr.indexOf('>') - start + 1;
+                    seen++;
+                }
+                byteCount += token.byteLength;
+                if (seen === i + 1 &&
+                    PdfCommentToken.isEofCommentToken(token)) {
+                    break;
+                }
+            }
+            const byteRange = [
+                0,
+                contentsOffset,
+                contentsOffset + contentsLength,
+                byteCount - (contentsOffset + contentsLength),
+            ];
+            signature.setByteRange(byteRange);
+            const allBytes = document.toBytes();
+            const toSign = concatUint8Arrays(allBytes.slice(byteRange[0], byteRange[1]), allBytes.slice(byteRange[2], byteRange[3] + byteRange[2]));
+            const { signedBytes, revocationInfo } = await signature.sign({
+                bytes: toSign,
+                embedRevocationInfo: !Boolean(dss),
+            });
+            signature.setSignedBytes(signedBytes);
+            if (dss && revocationInfo) {
+                await dss.addRevocationInfo(revocationInfo);
+            }
+        }
+        if (dss && !dss.isEmpty()) {
+            await document.setDocumentSecurityStore(dss);
+        }
+        return document;
+    }
+}

package/{packages/pdf-lite/src/signing/types.ts → dist/signing/types.d.ts}

@@ -1,12 +1,11 @@
-import { HashAlgorithm } from 'pki-lite/core/crypto/index.js'
-import { PdfDictionary } from '../core/objects/pdf-dictionary'
-import { PdfName } from '../core/objects/pdf-name'
-import { PdfHexadecimal } from '../core/objects/pdf-hexadecimal'
-import { PdfArray } from '../core/objects/pdf-array'
-import { PdfNumber } from '../core/objects/pdf-number'
-import { PdfString } from '../core/objects/pdf-string'
-import { ByteArray } from '../types'
-
+import { HashAlgorithm } from 'pki-lite/core/crypto/index.js';
+import { PdfDictionary } from '../core/objects/pdf-dictionary';
+import { PdfName } from '../core/objects/pdf-name';
+import { PdfHexadecimal } from '../core/objects/pdf-hexadecimal';
+import { PdfArray } from '../core/objects/pdf-array';
+import { PdfNumber } from '../core/objects/pdf-number';
+import { PdfString } from '../core/objects/pdf-string';
+import { ByteArray } from '../types';
 /**
  * PDF signature subfilter types defining the signature format.
  * - 'adbe.pkcs7.detached': PKCS#7 detached signature
@@ -15,72 +14,65 @@ import { ByteArray } from '../types'
  * - 'ETSI.CAdES.detached': CAdES detached signature
  * - 'ETSI.RFC3161': RFC 3161 timestamp signature
  */
-export type PdfSignatureSubType =
-    | 'adbe.pkcs7.detached'
-    | 'adbe.pkcs7.sha1'
-    | 'adbe.x509.rsa_sha1'
-    | 'ETSI.CAdES.detached'
-    | 'ETSI.RFC3161'
-
+export type PdfSignatureSubType = 'adbe.pkcs7.detached' | 'adbe.pkcs7.sha1' | 'adbe.x509.rsa_sha1' | 'ETSI.CAdES.detached' | 'ETSI.RFC3161';
 /**
  * PDF signature type.
  * - 'Sig': Standard digital signature
  * - 'DocTimeStamp': Document timestamp
  */
-export type PdfSignatureType = 'Sig' | 'DocTimeStamp'
-
+export type PdfSignatureType = 'Sig' | 'DocTimeStamp';
 /**
  * Entries in a PDF signature dictionary.
  */
 export type PdfSignatureDictionaryEntries = {
-    Type: PdfName<PdfSignatureType>
-    Filter: PdfName
-    SubFilter: PdfName<PdfSignatureSubType>
-    Contents: PdfHexadecimal
-    ByteRange: PdfArray<PdfNumber>
-    Reason?: PdfString
-    M?: PdfString
-    Name?: PdfString
-    Reference?: PdfArray<PdfDictionary>
-    Location?: PdfString
-    ContactInfo?: PdfString
-    V?: PdfName<'2.2'>
-    Changes?: PdfArray<PdfNumber>
-    Cert?: PdfArray<PdfString | PdfHexadecimal> | PdfString | PdfHexadecimal
-}
-
+    Type: PdfName<PdfSignatureType>;
+    Filter: PdfName;
+    SubFilter: PdfName<PdfSignatureSubType>;
+    Contents: PdfHexadecimal;
+    ByteRange: PdfArray<PdfNumber>;
+    Reason?: PdfString;
+    M?: PdfString;
+    Name?: PdfString;
+    Reference?: PdfArray<PdfDictionary>;
+    Location?: PdfString;
+    ContactInfo?: PdfString;
+    V?: PdfName<'2.2'>;
+    Changes?: PdfArray<PdfNumber>;
+    Cert?: PdfArray<PdfString | PdfHexadecimal> | PdfString | PdfHexadecimal;
+};
 /**
  * Configuration for a timestamp authority (TSA).
  */
 export type TimeStampAuthority = {
     /** URL of the timestamp authority service. */
-    url: string
+    url: string;
     /** Optional username for authentication. */
-    username?: string
+    username?: string;
     /** Optional password for authentication. */
-    password?: string
-}
-
+    password?: string;
+};
 /**
  * Revocation information for certificate validation.
  */
 export type RevocationInfo = {
     /** Certificate Revocation Lists (CRLs). */
-    crls?: ByteArray[]
+    crls?: ByteArray[];
     /** OCSP responses. */
-    ocsps?: ByteArray[]
+    ocsps?: ByteArray[];
     /** Other revocation information types. */
-    otherRevInfo?: { type: string; value: ByteArray }[]
-}
-
+    otherRevInfo?: {
+        type: string;
+        value: ByteArray;
+    }[];
+};
 /**
  * Signature policy document reference for CAdES signatures.
  */
 export type SignaturePolicyDocument = {
     /** Object Identifier for the signature policy. */
-    oid: string
+    oid: string;
     /** Hash of the policy document. */
-    hash: ByteArray
+    hash: ByteArray;
     /** Hash algorithm used for the policy document. */
-    hashAlgorithm: HashAlgorithm
-}
+    hashAlgorithm: HashAlgorithm;
+};

package/dist/signing/types.js

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

package/dist/signing/utils.d.ts

@@ -0,0 +1,32 @@
+import { RevocationInfo } from './types';
+import { ByteArray } from '../types';
+/**
+ * Fetches revocation information (CRLs and OCSPs) for certificates.
+ * Uses the certificate's embedded URLs to retrieve revocation data.
+ *
+ * @param options - Configuration for fetching revocation info.
+ * @param options.certificates - Array of DER-encoded certificates.
+ * @param options.issuerCertificate - Optional issuer certificate for OCSP requests.
+ * @param options.ocspUrls - Optional additional OCSP URLs.
+ * @param options.crlUrls - Optional additional CRL URLs.
+ * @param options.retrieveOcsps - Whether to fetch OCSP responses (default: true).
+ * @param options.retrieveCrls - Whether to fetch CRLs (default: true).
+ * @returns The fetched revocation information.
+ *
+ * @example
+ * ```typescript
+ * const revInfo = await fetchRevocationInfo({
+ *     certificates: [certBytes],
+ *     retrieveCrls: true,
+ *     retrieveOcsps: true
+ * })
+ * ```
+ */
+export declare function fetchRevocationInfo(options: {
+    certificates: ByteArray[];
+    issuerCertificate?: ByteArray;
+    ocspUrls?: string[];
+    crlUrls?: string[];
+    retrieveOcsps?: boolean;
+    retrieveCrls?: boolean;
+}): Promise<RevocationInfo>;

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

@@ -1,7 +1,4 @@
-import { Certificate } from 'pki-lite/x509/Certificate'
-import { RevocationInfo } from './types'
-import { ByteArray } from '../types'
-
+import { Certificate } from 'pki-lite/x509/Certificate';
 /**
  * Fetches revocation information (CRLs and OCSPs) for certificates.
  * Uses the certificate's embedded URLs to retrieve revocation data.
@@ -24,48 +21,32 @@ import { ByteArray } from '../types'
  * })
  * ```
  */
-export async function fetchRevocationInfo(options: {
-    certificates: ByteArray[]
-    issuerCertificate?: ByteArray
-    ocspUrls?: string[] // URLs to fetch OCSPs from
-    crlUrls?: string[] // URLs to fetch CRLs from
-    retrieveOcsps?: boolean // Whether to fetch OCSPs
-    retrieveCrls?: boolean // Whether to fetch CRLs
-}): Promise<RevocationInfo> {
-    const { certificates, retrieveCrls = true, retrieveOcsps = true } = options
-
-    const crls: ByteArray[] = []
-    const ocsps: ByteArray[] = []
-
+export async function fetchRevocationInfo(options) {
+    const { certificates, retrieveCrls = true, retrieveOcsps = true } = options;
+    const crls = [];
+    const ocsps = [];
     for (const certificateBytes of certificates) {
-        const certificate = Certificate.fromDer(certificateBytes)
-
+        const certificate = Certificate.fromDer(certificateBytes);
         if (retrieveCrls) {
-            const crl = await certificate.requestCrl()
-
+            const crl = await certificate.requestCrl();
             if (crl) {
-                crls.push(crl.toDer())
+                crls.push(crl.toDer());
             }
         }
-
         if (retrieveOcsps) {
             const ocsp = await certificate.requestOcsp({
                 issuerCertificate: options.issuerCertificate
-                    ? Certificate.fromDer(
-                          options.issuerCertificate as ByteArray,
-                      )
+                    ? Certificate.fromDer(options.issuerCertificate)
                     : undefined,
-            })
-
+            });
             if (ocsp) {
-                ocsps.push(ocsp.toDer())
+                ocsps.push(ocsp.toDer());
             }
         }
     }
-
     return {
         crls,
         ocsps,
         otherRevInfo: [],
-    }
+    };
 }

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+export type ByteArray = Uint8Array<ArrayBuffer>;
+export type HashAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
+export type ChangeType = 'add' | 'update' | 'delete';
+export type PdfEncryptionAlgorithm = 'RC4-40' | 'RC4-128' | 'AES-128-CBC' | 'AES-256-CBC' | 'none';
+export type DecodeParms = {
+    Predictor?: number;
+    Columns?: number;
+    Colors?: number;
+    BitsPerComponent?: number;
+};
+export type PdfPermissions = {
+    all?: boolean;
+    print?: boolean;
+    modify?: boolean;
+    copy?: boolean;
+    annotate?: boolean;
+    fill?: boolean;
+    extract?: boolean;
+    assemble?: boolean;
+    printHighQuality?: boolean;
+};
+export declare const PERMISSION_FLAGS: Record<keyof PdfPermissions, number>;
+export type PdfVersion = 1.3 | 1.4 | 1.5 | 1.6 | 1.7 | 2.0;

package/dist/types.js

@@ -0,0 +1,11 @@
+export const PERMISSION_FLAGS = {
+    all: 0xffffffff,
+    print: 0x00000004,
+    modify: 0x00000008,
+    copy: 0x00000010,
+    annotate: 0x00000020,
+    fill: 0x00000100,
+    extract: 0x00000200,
+    assemble: 0x00000400,
+    printHighQuality: 0x00000800,
+};

package/dist/utils/IterableReadableStream.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A ReadableStream that supports async iteration.
+ * Extends the standard ReadableStream with Symbol.asyncIterator support.
+ *
+ * @typeParam T - The type of chunks yielded by the stream.
+ *
+ * @example
+ * ```typescript
+ * const stream = new IterableReadableStream<Uint8Array>(...)
+ * for await (const chunk of stream) {
+ *   console.log(chunk)
+ * }
+ * ```
+ */
+export declare class IterableReadableStream<T> extends ReadableStream<T> {
+    /**
+     * Returns an async iterator for the stream.
+     *
+     * @returns An async iterator that yields chunks from the stream.
+     */
+    [Symbol.asyncIterator](): {
+        next(): Promise<IteratorResult<T>>;
+    };
+}

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

@@ -12,19 +12,19 @@
  * }
  * ```
  */
-export class IterableReadableStream<T> extends ReadableStream<T> {
+export class IterableReadableStream extends ReadableStream {
     /**
      * Returns an async iterator for the stream.
      *
      * @returns An async iterator that yields chunks from the stream.
      */
     [Symbol.asyncIterator]() {
-        const reader = this.getReader()
+        const reader = this.getReader();
         return {
-            async next(): Promise<IteratorResult<T>> {
-                const result = await reader.read()
-                return result as IteratorResult<T>
+            async next() {
+                const result = await reader.read();
+                return result;
             },
-        }
+        };
     }
 }

package/dist/utils/algos.d.ts

@@ -0,0 +1,242 @@
+import 'pki-lite-crypto-extended';
+import { ByteArray } from '../types.js';
+/**
+ * Computes the SHA-1 hash of the input data.
+ *
+ * @param input - The data to hash.
+ * @returns A promise that resolves to the SHA-1 hash as a byte array.
+ *
+ * @example
+ * ```typescript
+ * const hash = await sha1(new Uint8Array([1, 2, 3]))
+ * ```
+ */
+export declare function sha1(input: ByteArray): Promise<ByteArray>;
+/**
+ * Computes the SHA-256 hash of the input data.
+ *
+ * @param input - The data to hash.
+ * @returns A promise that resolves to the SHA-256 hash as a byte array.
+ *
+ * @example
+ * ```typescript
+ * const hash = await sha256(new Uint8Array([1, 2, 3]))
+ * ```
+ */
+export declare function sha256(input: ByteArray): Promise<ByteArray>;
+/**
+ * Computes the SHA-384 hash of the input data.
+ *
+ * @param input - The data to hash.
+ * @returns A promise that resolves to the SHA-384 hash as a byte array.
+ *
+ * @example
+ * ```typescript
+ * const hash = await sha384(new Uint8Array([1, 2, 3]))
+ * ```
+ */
+export declare function sha384(input: ByteArray): Promise<ByteArray>;
+/**
+ * Computes the SHA-512 hash of the input data.
+ *
+ * @param input - The data to hash.
+ * @returns A promise that resolves to the SHA-512 hash as a byte array.
+ *
+ * @example
+ * ```typescript
+ * const hash = await sha512(new Uint8Array([1, 2, 3]))
+ * ```
+ */
+export declare function sha512(input: ByteArray): Promise<ByteArray>;
+/**
+ * Computes the MD5 hash of the input data.
+ *
+ * @param input - The data to hash.
+ * @returns A promise that resolves to the MD5 hash as a byte array.
+ *
+ * @example
+ * ```typescript
+ * const hash = await md5(new Uint8Array([1, 2, 3]))
+ * ```
+ */
+export declare function md5(input: ByteArray): Promise<ByteArray>;
+/**
+ * Computes a cryptographic hash of the input data using the specified algorithm.
+ *
+ * @param input - The data to hash.
+ * @param algorithm - The hash algorithm to use. Defaults to 'SHA-256'.
+ * @returns A promise that resolves to the hash as a byte array.
+ * @throws Error if an unsupported hash algorithm is specified.
+ *
+ * @example
+ * ```typescript
+ * const hash = await hash(data, 'SHA-256')
+ * ```
+ */
+export declare function hash(input: ByteArray, algorithm?: 'SHA-256' | 'SHA-384' | 'SHA-512' | 'MD5' | 'SHA-1'): Promise<ByteArray>;
+/**
+ * Generates cryptographically secure random bytes.
+ *
+ * @param length - The number of random bytes to generate.
+ * @returns A byte array containing random bytes.
+ * @throws Error if length is not a positive integer.
+ *
+ * @example
+ * ```typescript
+ * const randomBytes = getRandomBytes(16) // 16 random bytes
+ * ```
+ */
+export declare function getRandomBytes(length: number): ByteArray;
+/**
+ * Encrypts data using AES-128-CBC mode.
+ *
+ * @param key - The 16-byte encryption key.
+ * @param data - The data to encrypt.
+ * @param iv - The 16-byte initialization vector. Defaults to zero IV.
+ * @returns A promise that resolves to the encrypted data.
+ * @throws Error if the key is not exactly 16 bytes.
+ *
+ * @example
+ * ```typescript
+ * const encrypted = await aes128cbcEncrypt(key, plaintext, iv)
+ * ```
+ */
+export declare function aes128cbcEncrypt(key: ByteArray, data: ByteArray, iv?: ByteArray): Promise<ByteArray>;
+/**
+ * Decrypts data using AES-128-CBC mode.
+ *
+ * @param key - The 16-byte decryption key.
+ * @param encrypted - The encrypted data to decrypt.
+ * @param iv - The 16-byte initialization vector. Defaults to zero IV.
+ * @returns A promise that resolves to the decrypted data.
+ * @throws Error if the key is not exactly 16 bytes or encrypted data is too short.
+ *
+ * @example
+ * ```typescript
+ * const decrypted = await aes128cbcDecrypt(key, ciphertext, iv)
+ * ```
+ */
+export declare function aes128cbcDecrypt(key: ByteArray, encrypted: ByteArray, iv?: ByteArray): Promise<ByteArray>;
+/**
+ * Encrypts data using AES-256-CBC mode.
+ *
+ * @param fileKey - The 32-byte encryption key.
+ * @param block - The data to encrypt.
+ * @param iv - The 16-byte initialization vector. Defaults to zero IV.
+ * @returns A promise that resolves to the encrypted data.
+ *
+ * @example
+ * ```typescript
+ * const encrypted = await aes256cbcEncrypt(key, plaintext, iv)
+ * ```
+ */
+export declare function aes256cbcEncrypt(fileKey: ByteArray, block: ByteArray, iv?: ByteArray): Promise<ByteArray>;
+/**
+ * Decrypts data using AES-256-CBC mode.
+ *
+ * @param fileKey - The 32-byte decryption key.
+ * @param ciphertext - The encrypted data to decrypt.
+ * @param iv - The 16-byte initialization vector. Defaults to zero IV.
+ * @returns A promise that resolves to the decrypted data.
+ *
+ * @example
+ * ```typescript
+ * const decrypted = await aes256cbcDecrypt(key, ciphertext, iv)
+ * ```
+ */
+export declare function aes256cbcDecrypt(fileKey: ByteArray, ciphertext: ByteArray, iv?: ByteArray): Promise<ByteArray>;
+/**
+ * Encrypts data using AES-256-ECB mode.
+ *
+ * @param fileKey - The 32-byte encryption key.
+ * @param data - The data to encrypt.
+ * @returns A promise that resolves to the encrypted data.
+ * @throws Error if the key is not exactly 32 bytes.
+ *
+ * @example
+ * ```typescript
+ * const encrypted = await aes256ecbEncrypt(key, plaintext)
+ * ```
+ */
+export declare function aes256ecbEncrypt(fileKey: ByteArray, data: ByteArray): Promise<ByteArray>;
+/**
+ * Decrypts data using AES-256-ECB mode.
+ *
+ * @param fileKey - The 32-byte decryption key.
+ * @param encrypted - The encrypted data to decrypt.
+ * @returns A promise that resolves to the decrypted data.
+ * @throws Error if the key is not exactly 32 bytes.
+ *
+ * @example
+ * ```typescript
+ * const decrypted = await aes256ecbDecrypt(key, ciphertext)
+ * ```
+ */
+export declare function aes256ecbDecrypt(fileKey: ByteArray, encrypted: ByteArray): Promise<ByteArray>;
+/**
+ * Encrypts data using AES-128-CBC mode without PKCS#7 padding.
+ *
+ * @param key - The 16-byte encryption key.
+ * @param data - The data to encrypt. Must be a multiple of 16 bytes.
+ * @param iv - The 16-byte initialization vector.
+ * @returns A promise that resolves to the encrypted data.
+ *
+ * @example
+ * ```typescript
+ * const encrypted = await aes128CbcNoPaddingEncrypt(key, data, iv)
+ * ```
+ */
+export declare function aes128CbcNoPaddingEncrypt(key: ByteArray, data: ByteArray, iv: ByteArray): Promise<ByteArray>;
+/**
+ * Encrypts data using AES-256-CBC mode without PKCS#7 padding.
+ *
+ * @param key - The 32-byte encryption key.
+ * @param data - The data to encrypt. Must be a multiple of 16 bytes.
+ * @param iv - The 16-byte initialization vector.
+ * @returns A promise that resolves to the encrypted data.
+ *
+ * @example
+ * ```typescript
+ * const encrypted = await aes256CbcNoPaddingEncrypt(key, data, iv)
+ * ```
+ */
+export declare function aes256CbcNoPaddingEncrypt(key: ByteArray, data: ByteArray, iv: ByteArray): Promise<ByteArray>;
+/**
+ * Decrypts data using AES-256-CBC mode without PKCS#7 padding.
+ *
+ * @param key - The 32-byte decryption key.
+ * @param ciphertext - The encrypted data to decrypt.
+ * @param iv - The 16-byte initialization vector. Defaults to zero IV.
+ * @returns A promise that resolves to the decrypted data.
+ *
+ * @example
+ * ```typescript
+ * const decrypted = await aes256CbcNoPaddingDecrypt(key, ciphertext, iv)
+ * ```
+ */
+export declare function aes256CbcNoPaddingDecrypt(key: ByteArray, ciphertext: ByteArray, iv?: ByteArray): Promise<ByteArray>;
+/**
+ * Compresses data using the DEFLATE algorithm.
+ *
+ * @param data - The data to compress.
+ * @returns The compressed data as a byte array.
+ *
+ * @example
+ * ```typescript
+ * const compressed = deflateData(rawData)
+ * ```
+ */
+export declare function deflateData(data: ByteArray): ByteArray;
+/**
+ * Decompresses data using the INFLATE algorithm (reverses DEFLATE).
+ *
+ * @param data - The compressed data to decompress.
+ * @returns The decompressed data as a byte array.
+ * @throws Error if inflation fails due to invalid or corrupted data.
+ *
+ * @example
+ * ```typescript
+ * const decompressed = inflateData(compressedData)
+ * ```
+ */
+export declare function inflateData(data: ByteArray): ByteArray;