@chr33s/pdf-common 5.0.0

package/src/compression.ts

@@ -0,0 +1,35 @@
+export type CompressionFormat = "deflate" | "deflate-raw" | "gzip";
+
+function concatUint8Arrays(arrays: Uint8Array[]) {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+
+async function readAllChunks(stream: ReadableStream<Uint8Array>) {
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) chunks.push(value);
+  }
+
+  return concatUint8Arrays(chunks);
+}
+
+export async function deflate(data: Uint8Array, format: CompressionFormat = "deflate") {
+  const stream = new Blob([data]).stream().pipeThrough(new CompressionStream(format));
+  return readAllChunks(stream);
+}
+
+export async function inflate(data: Uint8Array, format: CompressionFormat = "deflate") {
+  const stream = new Blob([data]).stream().pipeThrough(new DecompressionStream(format));
+  return readAllChunks(stream);
+}

package/src/crypto/aes.ts

@@ -0,0 +1,93 @@
+import { Buffer } from "node:buffer";
+import { createCipheriv, createDecipheriv } from "node:crypto";
+import type { Mode } from "./mode.js";
+import { CBC } from "./mode.js";
+import type { Padding } from "./padding.js";
+import { Pkcs7 } from "./padding.js";
+import { WordArray } from "./word-array.js";
+
+export interface CipherResult {
+  ciphertext: WordArray;
+}
+
+export interface AESOptions {
+  mode?: Mode;
+  padding?: Padding;
+  iv?: WordArray;
+}
+
+export interface AESStatic {
+  encrypt(message: WordArray, key: WordArray, options?: AESOptions): CipherResult;
+  decrypt(ciphertext: WordArray, key: WordArray, options?: AESOptions): CipherResult;
+}
+
+function getAlgorithm(keyBytes: Uint8Array, mode: Mode): string {
+  const keyBits = keyBytes.length * 8;
+  const modeName = mode.name.toLowerCase();
+  return `aes-${keyBits}-${modeName}`;
+}
+
+function encrypt(message: WordArray, key: WordArray, options: AESOptions = {}): CipherResult {
+  const mode = options.mode || CBC;
+  const padding = options.padding || Pkcs7;
+
+  const keyBytes = key.toUint8Array();
+  const algorithm = getAlgorithm(keyBytes, mode);
+
+  // Clone and pad the message
+  const paddedMessage = message.clone();
+  padding.pad(paddedMessage, 4); // AES block size is 4 words (16 bytes)
+  const messageBytes = paddedMessage.toUint8Array();
+
+  // Get IV (for CBC mode)
+  let iv: Uint8Array | null = null;
+  if (mode === CBC) {
+    iv = options.iv ? options.iv.toUint8Array() : new Uint8Array(16);
+  }
+
+  const cipher = createCipheriv(algorithm, keyBytes, iv);
+  cipher.setAutoPadding(false); // We handle padding ourselves
+
+  const encrypted = Buffer.concat([cipher.update(messageBytes), cipher.final()]);
+
+  return {
+    ciphertext: WordArray.fromUint8Array(new Uint8Array(encrypted)),
+  };
+}
+
+/**
+ * AES decryption using node:crypto
+ */
+function decrypt(ciphertext: WordArray, key: WordArray, options: AESOptions = {}): CipherResult {
+  const mode = options.mode || CBC;
+  const padding = options.padding || Pkcs7;
+
+  const keyBytes = key.toUint8Array();
+  const algorithm = getAlgorithm(keyBytes, mode);
+  const ciphertextBytes = ciphertext.toUint8Array();
+
+  // Get IV (for CBC mode)
+  let iv: Uint8Array | null = null;
+  if (mode === CBC) {
+    iv = options.iv ? options.iv.toUint8Array() : new Uint8Array(16);
+  }
+
+  const decipher = createDecipheriv(algorithm, keyBytes, iv);
+  decipher.setAutoPadding(false); // We handle padding ourselves
+
+  const decrypted = Buffer.concat([decipher.update(ciphertextBytes), decipher.final()]);
+  const result = WordArray.fromUint8Array(new Uint8Array(decrypted));
+
+  padding.unpad(result);
+
+  return {
+    ciphertext: result,
+  };
+}
+
+export const AES: AESStatic = {
+  encrypt,
+  decrypt,
+};
+
+export default AES;

package/src/crypto/index.ts

@@ -0,0 +1,7 @@
+export { AES } from "./aes.js";
+export { MD5 } from "./md5.js";
+export * as mode from "./mode.js";
+export * as padding from "./padding.js";
+export { RC4 } from "./rc4.js";
+export { SHA256 } from "./sha256.js";
+export { WordArray } from "./word-array.js";

package/src/crypto/md5.ts

@@ -0,0 +1,10 @@
+import { createHash } from "node:crypto";
+import { WordArray } from "./word-array.js";
+
+export function MD5(message: WordArray | string): WordArray {
+  const data = typeof message === "string" ? message : message.toUint8Array();
+  const hash = createHash("md5").update(data).digest();
+  return WordArray.fromUint8Array(hash);
+}
+
+export default MD5;

package/src/crypto/mode.ts

@@ -0,0 +1,11 @@
+export interface Mode {
+  name: string;
+}
+
+export const CBC: Mode = {
+  name: "CBC",
+};
+
+export const ECB: Mode = {
+  name: "ECB",
+};

package/src/crypto/padding.ts

@@ -0,0 +1,36 @@
+import { WordArray } from "./word-array.js";
+
+export interface Padding {
+  pad(data: WordArray, blockSize: number): void;
+  unpad(data: WordArray): void;
+}
+
+export const Pkcs7: Padding = {
+  pad(data: WordArray, blockSize: number): void {
+    const blockSizeBytes = blockSize * 4;
+    const nPaddingBytes = blockSizeBytes - (data.sigBytes % blockSizeBytes);
+    const paddingWord =
+      (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;
+
+    const paddingWords: number[] = [];
+    for (let i = 0; i < nPaddingBytes; i += 4) {
+      paddingWords.push(paddingWord);
+    }
+    const padding = new WordArray(paddingWords, nPaddingBytes);
+    data.concat(padding);
+  },
+
+  unpad(data: WordArray): void {
+    const nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
+    data.sigBytes -= nPaddingBytes;
+  },
+};
+
+export const NoPadding: Padding = {
+  pad(_data: WordArray, _blockSize: number): void {
+    // No padding
+  },
+  unpad(_data: WordArray): void {
+    // No unpadding
+  },
+};

package/src/crypto/rc4.ts

@@ -0,0 +1,65 @@
+import { WordArray } from "./word-array.js";
+
+export interface CipherResult {
+  ciphertext: WordArray;
+}
+
+export interface RC4Static {
+  encrypt(message: WordArray, key: WordArray): CipherResult;
+  decrypt(ciphertext: WordArray, key: WordArray): CipherResult;
+}
+
+function rc4Process(data: Uint8Array, key: Uint8Array): Uint8Array {
+  // Key Scheduling Algorithm (KSA)
+  const S = new Uint8Array(256);
+  for (let i = 0; i < 256; i++) {
+    S[i] = i;
+  }
+
+  let j = 0;
+  for (let i = 0; i < 256; i++) {
+    j = (j + S[i] + key[i % key.length]) & 0xff;
+    // Swap S[i] and S[j]
+    const temp = S[i];
+    S[i] = S[j];
+    S[j] = temp;
+  }
+
+  // Pseudo-Random Generation Algorithm (PRGA)
+  const result = new Uint8Array(data.length);
+  let i = 0;
+  j = 0;
+  for (let k = 0; k < data.length; k++) {
+    i = (i + 1) & 0xff;
+    j = (j + S[i]) & 0xff;
+    // Swap S[i] and S[j]
+    const temp = S[i];
+    S[i] = S[j];
+    S[j] = temp;
+    // Generate keystream byte and XOR with data
+    result[k] = data[k] ^ S[(S[i] + S[j]) & 0xff];
+  }
+
+  return result;
+}
+
+function encrypt(message: WordArray, key: WordArray): CipherResult {
+  const keyBytes = key.toUint8Array();
+  const messageBytes = message.toUint8Array();
+  const encrypted = rc4Process(messageBytes, keyBytes);
+
+  return {
+    ciphertext: WordArray.fromUint8Array(encrypted),
+  };
+}
+
+function decrypt(ciphertext: WordArray, key: WordArray): CipherResult {
+  return encrypt(ciphertext, key);
+}
+
+export const RC4: RC4Static = {
+  encrypt,
+  decrypt,
+};
+
+export default RC4;

package/src/crypto/sha256.ts

@@ -0,0 +1,10 @@
+import { createHash } from "node:crypto";
+import { WordArray } from "./word-array.js";
+
+export function SHA256(message: WordArray | string): WordArray {
+  const data = typeof message === "string" ? message : message.toUint8Array();
+  const hash = createHash("sha256").update(data).digest();
+  return WordArray.fromUint8Array(hash);
+}
+
+export default SHA256;

package/src/crypto/word-array.ts

@@ -0,0 +1,147 @@
+import { randomBytes } from "node:crypto";
+
+export interface Encoder {
+  stringify(wordArray: WordArray): string;
+  parse(str: string): WordArray;
+}
+
+export class WordArray {
+  words: number[];
+  sigBytes: number;
+
+  constructor(words?: number[], sigBytes?: number) {
+    this.words = words || [];
+    this.sigBytes = sigBytes !== undefined ? sigBytes : this.words.length * 4;
+  }
+
+  static create(words?: number[], sigBytes?: number): WordArray {
+    return new WordArray(words, sigBytes);
+  }
+
+  /**
+   * Creates a word array filled with random bytes.
+   */
+  static random(nBytes: number): WordArray {
+    const bytes = randomBytes(nBytes);
+    return WordArray.fromUint8Array(bytes);
+  }
+
+  /**
+   * Create WordArray from Uint8Array
+   */
+  static fromUint8Array(bytes: Uint8Array): WordArray {
+    const words: number[] = [];
+    for (let i = 0; i < bytes.length; i += 4) {
+      words.push(
+        ((bytes[i] || 0) << 24) |
+          ((bytes[i + 1] || 0) << 16) |
+          ((bytes[i + 2] || 0) << 8) |
+          (bytes[i + 3] || 0),
+      );
+    }
+    return new WordArray(words, bytes.length);
+  }
+
+  /**
+   * Convert WordArray to Uint8Array
+   */
+  toUint8Array(): Uint8Array {
+    const bytes = new Uint8Array(this.sigBytes);
+    for (let i = 0; i < this.sigBytes; i++) {
+      bytes[i] = (this.words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+    }
+    return bytes;
+  }
+
+  toString(encoder?: Encoder): string {
+    return (encoder || Hex).stringify(this);
+  }
+
+  concat(wordArray: WordArray): WordArray {
+    const thisWords = this.words;
+    const thatWords = wordArray.words;
+    const thisSigBytes = this.sigBytes;
+    const thatSigBytes = wordArray.sigBytes;
+
+    this.clamp();
+
+    if (thisSigBytes % 4) {
+      for (let i = 0; i < thatSigBytes; i++) {
+        const thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+        thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
+      }
+    } else {
+      for (let j = 0; j < thatSigBytes; j += 4) {
+        thisWords[(thisSigBytes + j) >>> 2] = thatWords[j >>> 2];
+      }
+    }
+    this.sigBytes += thatSigBytes;
+
+    return this;
+  }
+
+  clamp(): void {
+    const words = this.words;
+    const sigBytes = this.sigBytes;
+
+    words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
+    words.length = Math.ceil(sigBytes / 4);
+  }
+
+  clone(): WordArray {
+    return new WordArray(this.words.slice(0), this.sigBytes);
+  }
+}
+
+export const Hex: Encoder = {
+  stringify(wordArray: WordArray): string {
+    const words = wordArray.words;
+    const sigBytes = wordArray.sigBytes;
+    const hexChars: string[] = [];
+
+    for (let i = 0; i < sigBytes; i++) {
+      const bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+      hexChars.push((bite >>> 4).toString(16));
+      hexChars.push((bite & 0x0f).toString(16));
+    }
+
+    return hexChars.join("");
+  },
+
+  parse(hexStr: string): WordArray {
+    const hexStrLength = hexStr.length;
+    const words: number[] = [];
+
+    for (let i = 0; i < hexStrLength; i += 2) {
+      words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
+    }
+
+    return new WordArray(words, hexStrLength / 2);
+  },
+};
+
+export const Latin1: Encoder = {
+  stringify(wordArray: WordArray): string {
+    const words = wordArray.words;
+    const sigBytes = wordArray.sigBytes;
+    const chars: string[] = [];
+
+    for (let i = 0; i < sigBytes; i++) {
+      const bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+      chars.push(String.fromCharCode(bite));
+    }
+
+    return chars.join("");
+  },
+
+  parse(latin1Str: string): WordArray {
+    const length = latin1Str.length;
+    const words: number[] = [];
+
+    for (let i = 0; i < length; i++) {
+      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
+    }
+
+    return new WordArray(words, length);
+  },
+};

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./base64.js";
+export * as brotli from "./brotli.js";
+export * from "./compression.js";
+export * from "./crypto/index.js";

package/test/base64.test.ts

@@ -0,0 +1,173 @@
+import { Buffer } from "node:buffer";
+import { describe, expect, test } from "vitest";
+import {
+  base64,
+  decodeFromBase64,
+  decodeFromBase64DataUri,
+  encodeToBase64,
+} from "../src/base64.js";
+
+describe("encodeToBase64", () => {
+  test("matches Node.js Buffer encoding for simple data", () => {
+    const data = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
+    const result = encodeToBase64(data);
+    const expected = Buffer.from(data).toString("base64");
+    expect(result).toBe(expected);
+  });
+
+  test("matches Node.js Buffer encoding for binary data", () => {
+    const data = new Uint8Array([0, 1, 2, 255, 254, 253, 128, 64, 32]);
+    const result = encodeToBase64(data);
+    const expected = Buffer.from(data).toString("base64");
+    expect(result).toBe(expected);
+  });
+
+  test("matches Node.js Buffer encoding with padding (1 byte)", () => {
+    const data = new Uint8Array([65]); // requires == padding
+    const result = encodeToBase64(data);
+    const expected = Buffer.from(data).toString("base64");
+    expect(result).toBe(expected);
+  });
+
+  test("matches Node.js Buffer encoding with padding (2 bytes)", () => {
+    const data = new Uint8Array([65, 66]); // requires = padding
+    const result = encodeToBase64(data);
+    const expected = Buffer.from(data).toString("base64");
+    expect(result).toBe(expected);
+  });
+
+  test("matches Node.js Buffer encoding with no padding (3 bytes)", () => {
+    const data = new Uint8Array([65, 66, 67]); // no padding needed
+    const result = encodeToBase64(data);
+    const expected = Buffer.from(data).toString("base64");
+    expect(result).toBe(expected);
+  });
+
+  test("matches Node.js Buffer encoding for empty data", () => {
+    const data = new Uint8Array([]);
+    const result = encodeToBase64(data);
+    const expected = Buffer.from(data).toString("base64");
+    expect(result).toBe(expected);
+  });
+
+  test("matches Node.js Buffer encoding for large data", () => {
+    const data = new Uint8Array(1000);
+    for (let i = 0; i < data.length; i++) data[i] = i % 256;
+    const result = encodeToBase64(data);
+    const expected = Buffer.from(data).toString("base64");
+    expect(result).toBe(expected);
+  });
+});
+
+describe("decodeFromBase64", () => {
+  test("matches Node.js Buffer decoding for simple data", () => {
+    const base64 = "SGVsbG8="; // "Hello"
+    const result = decodeFromBase64(base64);
+    const expected = new Uint8Array(Buffer.from(base64, "base64"));
+    expect(result).toEqual(expected);
+  });
+
+  test("matches Node.js Buffer decoding for binary data", () => {
+    const base64 = "AAEC//79gEAg";
+    const result = decodeFromBase64(base64);
+    const expected = new Uint8Array(Buffer.from(base64, "base64"));
+    expect(result).toEqual(expected);
+  });
+
+  test("matches Node.js Buffer decoding with double padding", () => {
+    const base64 = "QQ==";
+    const result = decodeFromBase64(base64);
+    const expected = new Uint8Array(Buffer.from(base64, "base64"));
+    expect(result).toEqual(expected);
+  });
+
+  test("matches Node.js Buffer decoding with single padding", () => {
+    const base64 = "QUI=";
+    const result = decodeFromBase64(base64);
+    const expected = new Uint8Array(Buffer.from(base64, "base64"));
+    expect(result).toEqual(expected);
+  });
+
+  test("matches Node.js Buffer decoding with no padding", () => {
+    const base64 = "QUJD";
+    const result = decodeFromBase64(base64);
+    const expected = new Uint8Array(Buffer.from(base64, "base64"));
+    expect(result).toEqual(expected);
+  });
+
+  test("matches Node.js Buffer decoding for empty string", () => {
+    const base64 = "";
+    const result = decodeFromBase64(base64);
+    const expected = new Uint8Array(Buffer.from(base64, "base64"));
+    expect(result).toEqual(expected);
+  });
+
+  test("roundtrip encode/decode matches original data", () => {
+    const original = new Uint8Array([0, 127, 255, 1, 254, 128]);
+    const encoded = encodeToBase64(original);
+    const decoded = decodeFromBase64(encoded);
+    expect(decoded).toEqual(original);
+  });
+});
+
+describe("decodeFromBase64DataUri", () => {
+  const testData = new Uint8Array([37, 80, 68, 70]); // %PDF
+  const base64String = Buffer.from(testData).toString("base64");
+
+  test("can decode plain base64 strings", () => {
+    const result = decodeFromBase64DataUri(base64String);
+    expect(result).toEqual(testData);
+  });
+
+  test("can decode complete data URIs", () => {
+    const uri = `data:application/pdf;base64,${base64String}`;
+    const result = decodeFromBase64DataUri(uri);
+    expect(result).toEqual(testData);
+  });
+
+  test("can decode data URI without base64 marker", () => {
+    const uri = `data:application/pdf;,${base64String}`;
+    const result = decodeFromBase64DataUri(uri);
+    expect(result).toEqual(testData);
+  });
+
+  test("can decode data URI without mime type", () => {
+    const uri = `data:;,${base64String}`;
+    const result = decodeFromBase64DataUri(uri);
+    expect(result).toEqual(testData);
+  });
+
+  test("can decode minimal data URI", () => {
+    const uri = `,${base64String}`;
+    const result = decodeFromBase64DataUri(uri);
+    expect(result).toEqual(testData);
+  });
+
+  test("throws an error for invalid input", () => {
+    const uri = {} as any;
+    expect(() => decodeFromBase64DataUri(uri)).toThrow();
+  });
+});
+
+describe("encode/decode (base64-arraybuffer compatible)", () => {
+  test("encode matches Node.js Buffer encoding", () => {
+    const data = new Uint8Array([72, 101, 108, 108, 111]).buffer; // "Hello"
+    const result = base64.encode(data);
+    const expected = Buffer.from(new Uint8Array(data)).toString("base64");
+    expect(result).toBe(expected);
+  });
+
+  test("decode returns ArrayBuffer", () => {
+    const encoded = "SGVsbG8=";
+    const result = base64.decode(encoded);
+    expect(result).toBeInstanceOf(ArrayBuffer);
+    expect(new Uint8Array(result)).toEqual(new Uint8Array(Buffer.from(encoded, "base64")));
+  });
+
+  test("roundtrip encode/decode with ArrayBuffer", () => {
+    const original = new Uint8Array([0, 127, 255, 1, 254, 128]).buffer;
+    const encoded = base64.encode(original);
+    const decoded = base64.decode(encoded);
+    expect(new Uint8Array(decoded)).toEqual(new Uint8Array(original));
+  });
+});

package/test/brotli.test.data/0000000000000000.empty.br

@@ -0,0 +1 @@
+;

package/test/brotli.test.data/126d9a84a3d1b3ad.xyzzy.br

@@ -0,0 +1,2 @@
+��Xyzzy
+

package/test/brotli.test.data/5b5eb8c2e54aa1c4.fox.br

@@ -0,0 +1 @@
+�The quick brown fox jumps over the lazy dog