@jscrypto/classic 0.1.0

package/dist/index.mjs

@@ -0,0 +1,892 @@
+/*!
+ * @jscrypto/classic v0.1.0
+ * Copyright 2026 Chen, Yi-Cyuan
+ * Released under the MIT license
+ */
+
+// packages/classic/src/adapter/crypto-js.ts
+import CryptoJS from "crypto-js";
+function createCryptoJsBlockCipher(options) {
+  const { name, key, blockSize, algorithm } = options;
+  const keyWords = bytesToWordArray(key);
+  const encryptor = algorithm.createEncryptor(keyWords);
+  const decryptor = algorithm.createDecryptor(keyWords);
+  return {
+    blockSize,
+    encryptBlock(block) {
+      assertBlock(block, blockSize, name);
+      const words = bytesToWords(block);
+      encryptor.encryptBlock(words, 0);
+      return wordsToBytes(words, blockSize);
+    },
+    decryptBlock(block) {
+      assertBlock(block, blockSize, name);
+      const words = bytesToWords(block);
+      decryptor.decryptBlock(words, 0);
+      return wordsToBytes(words, blockSize);
+    }
+  };
+}
+function assertBlock(block, blockSize, name) {
+  if (block.length !== blockSize) {
+    throw new Error(`${name} block must be ${blockSize * 8} bits.`);
+  }
+}
+function bytesToWordArray(bytes) {
+  return CryptoJS.lib.WordArray.create(bytesToWords(bytes), bytes.length);
+}
+function bytesToWords(bytes) {
+  const words = [];
+  for (let i = 0; i < bytes.length; i++) {
+    words[i >>> 2] |= bytes[i] << 24 - i % 4 * 8;
+  }
+  return words;
+}
+function wordArrayToBytes(wordArray) {
+  return wordsToBytes(wordArray.words, wordArray.sigBytes);
+}
+function wordsToBytes(words, length) {
+  const bytes = new Uint8Array(length);
+  for (let i = 0; i < length; i++) {
+    bytes[i] = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+  }
+  return bytes;
+}
+
+// packages/classic/src/ciphers/aes.ts
+var aes = {
+  kind: "cipher",
+  name: "AES",
+  type: "block",
+  blockSize: 16,
+  keySizes: [16, 24, 32],
+  create(key) {
+    return createAesCipher(key);
+  }
+};
+function createAesCipher(key) {
+  if (![16, 24, 32].includes(key.length)) {
+    throw new Error("AES key must be 128, 192, or 256 bits.");
+  }
+  return createCryptoJsBlockCipher({
+    name: "AES",
+    key,
+    blockSize: 16,
+    algorithm: CryptoJS.algo.AES
+  });
+}
+
+// packages/classic/src/ciphers/des.ts
+var des = {
+  kind: "cipher",
+  name: "DES",
+  type: "block",
+  blockSize: 8,
+  keySizes: [8],
+  create(key) {
+    return createDesCipher(key);
+  }
+};
+function createDesCipher(key) {
+  if (key.length !== 8) {
+    throw new Error("DES key must be 64 bits.");
+  }
+  return createCryptoJsBlockCipher({
+    name: "DES",
+    key,
+    blockSize: 8,
+    algorithm: CryptoJS.algo.DES
+  });
+}
+
+// packages/classic/src/ciphers/rc4.ts
+var rc4 = {
+  kind: "cipher",
+  name: "RC4",
+  type: "stream",
+  createEncryptor({ key, options }) {
+    return createRc4Transform(key, getDrop(options, 0));
+  },
+  createDecryptor({ key, options }) {
+    return createRc4Transform(key, getDrop(options, 0));
+  }
+};
+var rc4Drop = {
+  kind: "cipher",
+  name: "RC4Drop",
+  type: "stream",
+  createEncryptor({ key, options }) {
+    return createRc4Transform(key, getDrop(options, 192));
+  },
+  createDecryptor({ key, options }) {
+    return createRc4Transform(key, getDrop(options, 192));
+  }
+};
+function createRc4Transform(key, drop = 0) {
+  assertKey(key);
+  assertDrop(drop);
+  const state = createInitialState(key);
+  for (let n = 0; n < drop; n++) {
+    nextByte(state);
+  }
+  let finalized = false;
+  const processInput = (input) => {
+    const output = new Uint8Array(input.length);
+    for (let i = 0; i < input.length; i++) {
+      output[i] = input[i] ^ nextByte(state);
+    }
+    return output;
+  };
+  return {
+    process(input) {
+      assertNotFinalized(finalized);
+      return processInput(input);
+    },
+    finalize(input = new Uint8Array()) {
+      assertNotFinalized(finalized);
+      finalized = true;
+      return input.length === 0 ? new Uint8Array() : processInput(input);
+    }
+  };
+}
+function createInitialState(key) {
+  const s = new Uint8Array(256);
+  for (let i = 0; i < s.length; i++) {
+    s[i] = i;
+  }
+  let j = 0;
+  for (let i = 0; i < s.length; i++) {
+    j = j + s[i] + key[i % key.length] & 255;
+    swap(s, i, j);
+  }
+  return { s, i: 0, j: 0 };
+}
+function nextByte(state) {
+  const { s } = state;
+  state.i = state.i + 1 & 255;
+  state.j = state.j + s[state.i] & 255;
+  swap(s, state.i, state.j);
+  return s[s[state.i] + s[state.j] & 255];
+}
+function swap(bytes, a, b) {
+  const value = bytes[a];
+  bytes[a] = bytes[b];
+  bytes[b] = value;
+}
+function getDrop(options, defaultDrop) {
+  if (!isRc4Options(options) || options.drop === void 0) {
+    return defaultDrop;
+  }
+  return options.drop;
+}
+function isRc4Options(options) {
+  return typeof options === "object" && options !== null;
+}
+function assertKey(key) {
+  if (key.length < 5) {
+    throw new Error("RC4 key should be greater or equal than 40 bits.");
+  }
+}
+function assertDrop(drop) {
+  if (!Number.isInteger(drop) || drop < 0) {
+    throw new RangeError("RC4 drop must be a non-negative integer.");
+  }
+}
+function assertNotFinalized(finalized) {
+  if (finalized) {
+    throw new Error("Transform is already finalized.");
+  }
+}
+
+// packages/classic/src/ciphers/triple-des.ts
+var tripleDes = {
+  kind: "cipher",
+  name: "TripleDES",
+  type: "block",
+  blockSize: 8,
+  keySizes: [16, 24],
+  create(key) {
+    return createTripleDesCipher(key);
+  }
+};
+function createTripleDesCipher(key) {
+  if (![16, 24].includes(key.length)) {
+    throw new Error("Triple DES key must be 128 or 192 bits.");
+  }
+  return createCryptoJsBlockCipher({
+    name: "Triple DES",
+    key,
+    blockSize: 8,
+    algorithm: CryptoJS.algo.TripleDES
+  });
+}
+
+// packages/classic/src/formats/openssl.ts
+import { concatBytes, equalBytes } from "@jscrypto/core";
+var OPENSSL_SALTED_MAGIC = new Uint8Array([
+  83,
+  97,
+  108,
+  116,
+  101,
+  100,
+  95,
+  95
+]);
+var opensslFormat = {
+  kind: "format",
+  name: "OpenSSL",
+  mediaType: "application/octet-stream",
+  stringify({ ciphertext, salt }) {
+    if (!salt) {
+      return ciphertext.slice();
+    }
+    assertSalt(salt);
+    return concatBytes(OPENSSL_SALTED_MAGIC, salt, ciphertext);
+  },
+  parse(input) {
+    if (!hasSaltHeader(input)) {
+      return { ciphertext: input.slice() };
+    }
+    return {
+      salt: input.slice(OPENSSL_SALTED_MAGIC.length, OPENSSL_SALTED_MAGIC.length + 8),
+      ciphertext: input.slice(OPENSSL_SALTED_MAGIC.length + 8)
+    };
+  }
+};
+function hasSaltHeader(input) {
+  return input.length >= 16 && equalBytes(input.subarray(0, OPENSSL_SALTED_MAGIC.length), OPENSSL_SALTED_MAGIC);
+}
+function assertSalt(salt) {
+  if (salt.length !== 8) {
+    throw new Error("OpenSSL salt must be 64 bits.");
+  }
+}
+
+// packages/classic/src/kdfs/evpkdf.ts
+var evpKdf = {
+  kind: "kdf",
+  name: "EvpKDF",
+  derive(params) {
+    return deriveEvpKdf(params);
+  }
+};
+function deriveEvpKdf(params) {
+  assertPositiveInteger(params.length, "EvpKDF length");
+  if (params.iterations !== void 0) {
+    assertPositiveInteger(params.iterations, "EvpKDF iterations");
+  }
+  const options = {
+    keySize: params.length / 4,
+    iterations: params.iterations ?? 1
+  };
+  const hasher = getHasher(params.hash);
+  if (hasher) {
+    options.hasher = hasher;
+  }
+  const derived = CryptoJS.EvpKDF(toCryptoJsInput(params.passphrase), toCryptoJsInput(params.salt), options);
+  return wordArrayToBytes(derived);
+}
+function toCryptoJsInput(input) {
+  return typeof input === "string" ? input : bytesToWordArray(input);
+}
+function getHasher(hash) {
+  if (!hash) {
+    return void 0;
+  }
+  const hasher = CryptoJS.algo[normalizeHashName(hash)];
+  if (!hasher) {
+    throw new Error(`Unsupported EvpKDF hash: ${hash}`);
+  }
+  return hasher;
+}
+function normalizeHashName(hash) {
+  return hash.replaceAll("-", "").toUpperCase();
+}
+function assertPositiveInteger(value, label) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new RangeError(`${label} must be a positive integer.`);
+  }
+}
+
+// packages/classic/src/kdfs/pbkdf2.ts
+var pbkdf2 = {
+  kind: "kdf",
+  name: "PBKDF2",
+  derive(params) {
+    return derivePbkdf2(params);
+  }
+};
+function derivePbkdf2(params) {
+  assertPositiveInteger2(params.iterations, "PBKDF2 iterations");
+  assertPositiveInteger2(params.length, "PBKDF2 length");
+  const options = {
+    keySize: params.length / 4,
+    iterations: params.iterations
+  };
+  const hasher = getHasher2(params.hash);
+  if (hasher) {
+    options.hasher = hasher;
+  }
+  const derived = CryptoJS.PBKDF2(toCryptoJsInput2(params.passphrase), toCryptoJsInput2(params.salt), options);
+  return wordArrayToBytes(derived);
+}
+function toCryptoJsInput2(input) {
+  return typeof input === "string" ? input : bytesToWordArray(input);
+}
+function getHasher2(hash) {
+  if (!hash) {
+    return void 0;
+  }
+  const hasher = CryptoJS.algo[normalizeHashName2(hash)];
+  if (!hasher) {
+    throw new Error(`Unsupported PBKDF2 hash: ${hash}`);
+  }
+  return hasher;
+}
+function normalizeHashName2(hash) {
+  return hash.replaceAll("-", "").toUpperCase();
+}
+function assertPositiveInteger2(value, label) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new RangeError(`${label} must be a positive integer.`);
+  }
+}
+
+// packages/classic/src/modes/cbc.ts
+import {
+  assertBlockMultiple as assertCoreBlockMultiple,
+  assertIv,
+  xorBytes
+} from "@jscrypto/core";
+var cbc = {
+  kind: "mode",
+  name: "CBC",
+  requiresPadding: true,
+  createEncryptor({ cipher, iv }) {
+    assertIv(cipher.blockSize, iv, "CBC");
+    return createCbcEncryptor(cipher, iv);
+  },
+  createDecryptor({ cipher, iv }) {
+    assertIv(cipher.blockSize, iv, "CBC");
+    return createCbcDecryptor(cipher, iv);
+  }
+};
+function createCbcEncryptor(cipher, iv) {
+  let previous = iv;
+  return {
+    process(input) {
+      assertBlockMultiple(cipher.blockSize, input);
+      const output = new Uint8Array(input.length);
+      for (let offset = 0; offset < input.length; offset += cipher.blockSize) {
+        const block = xorBytes(input.subarray(offset, offset + cipher.blockSize), previous);
+        const encrypted = cipher.encryptBlock(block);
+        output.set(encrypted, offset);
+        previous = encrypted;
+      }
+      return output;
+    },
+    finalize(input = new Uint8Array()) {
+      return input.length === 0 ? new Uint8Array() : this.process(input);
+    }
+  };
+}
+function createCbcDecryptor(cipher, iv) {
+  let previous = iv;
+  return {
+    process(input) {
+      assertBlockMultiple(cipher.blockSize, input);
+      const output = new Uint8Array(input.length);
+      for (let offset = 0; offset < input.length; offset += cipher.blockSize) {
+        const block = input.subarray(offset, offset + cipher.blockSize);
+        const decrypted = cipher.decryptBlock(block);
+        output.set(xorBytes(decrypted, previous), offset);
+        previous = block.slice();
+      }
+      return output;
+    },
+    finalize(input = new Uint8Array()) {
+      return input.length === 0 ? new Uint8Array() : this.process(input);
+    }
+  };
+}
+function assertBlockMultiple(blockSize, input) {
+  assertCoreBlockMultiple(input, blockSize, "CBC");
+}
+
+// packages/classic/src/modes/cfb.ts
+import { assertIv as assertIv2 } from "@jscrypto/core";
+var cfb = {
+  kind: "mode",
+  name: "CFB",
+  requiresPadding: false,
+  createEncryptor({ cipher, iv }) {
+    assertIv2(cipher.blockSize, iv, "CFB");
+    return createCfbEncryptor(cipher, iv);
+  },
+  createDecryptor({ cipher, iv }) {
+    assertIv2(cipher.blockSize, iv, "CFB");
+    return createCfbDecryptor(cipher, iv);
+  }
+};
+function createCfbEncryptor(cipher, iv) {
+  return createCfbTransform(cipher, iv, true);
+}
+function createCfbDecryptor(cipher, iv) {
+  return createCfbTransform(cipher, iv, false);
+}
+function createCfbTransform(cipher, iv, encrypting) {
+  let feedback = iv.slice();
+  let nextFeedback = new Uint8Array(cipher.blockSize);
+  let keystream = new Uint8Array(cipher.blockSize);
+  let position = 0;
+  return {
+    process(input) {
+      const output = new Uint8Array(input.length);
+      for (let i = 0; i < input.length; i++) {
+        if (position === 0) {
+          keystream = cipher.encryptBlock(feedback);
+        }
+        const inputByte = input[i];
+        const outputByte = inputByte ^ keystream[position];
+        output[i] = outputByte;
+        nextFeedback[position] = encrypting ? outputByte : inputByte;
+        position++;
+        if (position === cipher.blockSize) {
+          feedback = nextFeedback;
+          nextFeedback = new Uint8Array(cipher.blockSize);
+          position = 0;
+        }
+      }
+      return output;
+    },
+    finalize(input = new Uint8Array()) {
+      return input.length === 0 ? new Uint8Array() : this.process(input);
+    }
+  };
+}
+
+// packages/classic/src/modes/ctr.ts
+import { assertIv as assertIv3 } from "@jscrypto/core";
+var ctr = {
+  kind: "mode",
+  name: "CTR",
+  requiresPadding: false,
+  createEncryptor({ cipher, iv }) {
+    assertIv3(cipher.blockSize, iv, "CTR");
+    return createCtrTransform(cipher, iv);
+  },
+  createDecryptor({ cipher, iv }) {
+    assertIv3(cipher.blockSize, iv, "CTR");
+    return createCtrTransform(cipher, iv);
+  }
+};
+function createCtrTransform(cipher, iv) {
+  const counter = iv.slice();
+  let keystream = new Uint8Array(cipher.blockSize);
+  let position = cipher.blockSize;
+  return {
+    process(input) {
+      const output = new Uint8Array(input.length);
+      for (let i = 0; i < input.length; i++) {
+        if (position === cipher.blockSize) {
+          keystream = cipher.encryptBlock(counter);
+          incrementCounter(counter);
+          position = 0;
+        }
+        output[i] = input[i] ^ keystream[position];
+        position++;
+      }
+      return output;
+    },
+    finalize(input = new Uint8Array()) {
+      return input.length === 0 ? new Uint8Array() : this.process(input);
+    }
+  };
+}
+function incrementCounter(counter) {
+  for (let i = counter.length - 1; i >= 0; i--) {
+    counter[i] = counter[i] + 1 & 255;
+    if (counter[i] !== 0) {
+      return;
+    }
+  }
+}
+
+// packages/classic/src/modes/ecb.ts
+import { assertBlockMultiple as assertCoreBlockMultiple2 } from "@jscrypto/core";
+var ecb = {
+  kind: "mode",
+  name: "ECB",
+  requiresPadding: true,
+  createEncryptor({ cipher }) {
+    return createEcbEncryptor(cipher);
+  },
+  createDecryptor({ cipher }) {
+    return createEcbDecryptor(cipher);
+  }
+};
+function createEcbEncryptor(cipher) {
+  return {
+    process(input) {
+      assertBlockMultiple2(cipher.blockSize, input);
+      const output = new Uint8Array(input.length);
+      for (let offset = 0; offset < input.length; offset += cipher.blockSize) {
+        output.set(cipher.encryptBlock(input.subarray(offset, offset + cipher.blockSize)), offset);
+      }
+      return output;
+    },
+    finalize(input = new Uint8Array()) {
+      return input.length === 0 ? new Uint8Array() : this.process(input);
+    }
+  };
+}
+function createEcbDecryptor(cipher) {
+  return {
+    process(input) {
+      assertBlockMultiple2(cipher.blockSize, input);
+      const output = new Uint8Array(input.length);
+      for (let offset = 0; offset < input.length; offset += cipher.blockSize) {
+        output.set(cipher.decryptBlock(input.subarray(offset, offset + cipher.blockSize)), offset);
+      }
+      return output;
+    },
+    finalize(input = new Uint8Array()) {
+      return input.length === 0 ? new Uint8Array() : this.process(input);
+    }
+  };
+}
+function assertBlockMultiple2(blockSize, input) {
+  assertCoreBlockMultiple2(input, blockSize, "ECB");
+}
+
+// packages/classic/src/modes/gcm.ts
+var gcm = {
+  kind: "mode",
+  name: "GCM",
+  aead: true,
+  requiredBlockSize: 16,
+  requiresPadding: false,
+  createEncryptor() {
+    throw new Error("GCM mode is not implemented yet.");
+  },
+  createDecryptor() {
+    throw new Error("GCM mode is not implemented yet.");
+  }
+};
+
+// packages/classic/src/modes/ofb.ts
+import { assertIv as assertIv4 } from "@jscrypto/core";
+var ofb = {
+  kind: "mode",
+  name: "OFB",
+  requiresPadding: false,
+  createEncryptor({ cipher, iv }) {
+    assertIv4(cipher.blockSize, iv, "OFB");
+    return createOfbTransform(cipher, iv);
+  },
+  createDecryptor({ cipher, iv }) {
+    assertIv4(cipher.blockSize, iv, "OFB");
+    return createOfbTransform(cipher, iv);
+  }
+};
+function createOfbTransform(cipher, iv) {
+  let feedback = iv.slice();
+  let keystream = new Uint8Array(cipher.blockSize);
+  let position = cipher.blockSize;
+  return {
+    process(input) {
+      const output = new Uint8Array(input.length);
+      for (let i = 0; i < input.length; i++) {
+        if (position === cipher.blockSize) {
+          feedback = cipher.encryptBlock(feedback);
+          keystream = feedback;
+          position = 0;
+        }
+        output[i] = input[i] ^ keystream[position];
+        position++;
+      }
+      return output;
+    },
+    finalize(input = new Uint8Array()) {
+      return input.length === 0 ? new Uint8Array() : this.process(input);
+    }
+  };
+}
+
+// packages/classic/src/paddings/ansi-x923.ts
+import {
+  assertBlockSize as assertCoreBlockSize,
+  assertPaddedInput as assertCorePaddedInput,
+  getBlockPaddingLength
+} from "@jscrypto/core";
+var ansiX923 = {
+  kind: "padding",
+  name: "AnsiX923",
+  pad(input, blockSize) {
+    assertBlockSize(blockSize);
+    const paddingLength = getPaddingLength(input.length, blockSize);
+    const output = new Uint8Array(input.length + paddingLength);
+    output.set(input);
+    output[output.length - 1] = paddingLength;
+    return output;
+  },
+  unpad(input, blockSize) {
+    assertPaddedInput(input, blockSize);
+    const paddingLength = input[input.length - 1];
+    if (paddingLength === 0 || paddingLength > blockSize || paddingLength > input.length) {
+      throw new Error("Invalid ANSI X9.23 padding.");
+    }
+    for (let i = input.length - paddingLength; i < input.length - 1; i++) {
+      if (input[i] !== 0) {
+        throw new Error("Invalid ANSI X9.23 padding.");
+      }
+    }
+    return input.slice(0, input.length - paddingLength);
+  }
+};
+function assertBlockSize(blockSize) {
+  assertCoreBlockSize(blockSize, { max: 255 });
+}
+function assertPaddedInput(input, blockSize) {
+  assertCorePaddedInput(input, blockSize, "ANSI X9.23", { max: 255 });
+}
+function getPaddingLength(inputLength, blockSize) {
+  return getBlockPaddingLength(inputLength, blockSize);
+}
+
+// packages/classic/src/paddings/iso10126.ts
+import {
+  assertBlockSize as assertCoreBlockSize2,
+  assertPaddedInput as assertCorePaddedInput2,
+  getBlockPaddingLength as getBlockPaddingLength2
+} from "@jscrypto/core";
+var iso10126 = {
+  kind: "padding",
+  name: "Iso10126",
+  pad(input, blockSize) {
+    assertBlockSize2(blockSize);
+    const paddingLength = getPaddingLength2(input.length, blockSize);
+    const output = new Uint8Array(input.length + paddingLength);
+    output.set(input);
+    fillRandom(output.subarray(input.length, output.length - 1));
+    output[output.length - 1] = paddingLength;
+    return output;
+  },
+  unpad(input, blockSize) {
+    assertPaddedInput2(input, blockSize);
+    const paddingLength = input[input.length - 1];
+    if (paddingLength === 0 || paddingLength > blockSize || paddingLength > input.length) {
+      throw new Error("Invalid ISO 10126 padding.");
+    }
+    return input.slice(0, input.length - paddingLength);
+  }
+};
+function assertBlockSize2(blockSize) {
+  assertCoreBlockSize2(blockSize, { max: 255 });
+}
+function assertPaddedInput2(input, blockSize) {
+  assertCorePaddedInput2(input, blockSize, "ISO 10126", { max: 255 });
+}
+function getPaddingLength2(inputLength, blockSize) {
+  return getBlockPaddingLength2(inputLength, blockSize);
+}
+function fillRandom(bytes) {
+  if (bytes.length === 0) {
+    return;
+  }
+  const crypto = globalThis;
+  crypto.crypto?.getRandomValues(bytes);
+  if (bytes.some((byte) => byte !== 0)) {
+    return;
+  }
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Math.floor(Math.random() * 256);
+  }
+}
+
+// packages/classic/src/paddings/iso97971.ts
+import {
+  assertBlockSize as assertCoreBlockSize3,
+  assertPaddedInput as assertCorePaddedInput3
+} from "@jscrypto/core";
+var iso97971 = {
+  kind: "padding",
+  name: "Iso97971",
+  pad(input, blockSize) {
+    assertBlockSize3(blockSize);
+    const paddingLength = getPaddingLength3(input.length, blockSize);
+    const output = new Uint8Array(input.length + paddingLength);
+    output.set(input);
+    output[input.length] = 128;
+    return output;
+  },
+  unpad(input, blockSize) {
+    assertPaddedInput3(input, blockSize);
+    let index = input.length - 1;
+    while (index >= 0 && input[index] === 0) {
+      index--;
+    }
+    if (index < 0 || input[index] !== 128) {
+      throw new Error("Invalid ISO/IEC 9797-1 padding.");
+    }
+    return input.slice(0, index);
+  }
+};
+function assertBlockSize3(blockSize) {
+  assertCoreBlockSize3(blockSize);
+}
+function assertPaddedInput3(input, blockSize) {
+  assertCorePaddedInput3(input, blockSize, "ISO/IEC 9797-1");
+}
+function getPaddingLength3(inputLength, blockSize) {
+  const remainder = (inputLength + 1) % blockSize;
+  return 1 + (remainder === 0 ? 0 : blockSize - remainder);
+}
+
+// packages/classic/src/paddings/none.ts
+import { assertBlockMultiple as assertBlockMultiple3 } from "@jscrypto/core";
+var noPadding = {
+  kind: "padding",
+  name: "NoPadding",
+  pad(input, blockSize) {
+    assertMultiple(input, blockSize);
+    return input.slice();
+  },
+  unpad(input, blockSize) {
+    assertMultiple(input, blockSize);
+    return input.slice();
+  }
+};
+function assertMultiple(input, blockSize) {
+  assertBlockMultiple3(input, blockSize, "NoPadding");
+}
+
+// packages/classic/src/paddings/pkcs7.ts
+import { assertBlockSize as assertBlockSize4, assertPaddedInput as assertPaddedInput4, getBlockPaddingLength as getBlockPaddingLength3 } from "@jscrypto/core";
+var pkcs7 = {
+  kind: "padding",
+  name: "Pkcs7",
+  pad(input, blockSize) {
+    assertBlockSize4(blockSize, { max: 255 });
+    const paddingLength = getBlockPaddingLength3(input.length, blockSize);
+    const output = new Uint8Array(input.length + paddingLength);
+    output.set(input);
+    output.fill(paddingLength, input.length);
+    return output;
+  },
+  unpad(input, blockSize) {
+    assertPaddedInput4(input, blockSize, "PKCS#7", { max: 255 });
+    const paddingLength = input[input.length - 1];
+    if (paddingLength === 0 || paddingLength > blockSize || paddingLength > input.length) {
+      throw new Error("Invalid PKCS#7 padding.");
+    }
+    for (let i = input.length - paddingLength; i < input.length; i++) {
+      if (input[i] !== paddingLength) {
+        throw new Error("Invalid PKCS#7 padding.");
+      }
+    }
+    return input.slice(0, input.length - paddingLength);
+  }
+};
+
+// packages/classic/src/paddings/zero.ts
+var zeroPadding = {
+  kind: "padding",
+  name: "ZeroPadding",
+  pad(input, blockSize) {
+    if (!Number.isInteger(blockSize) || blockSize <= 0) {
+      throw new RangeError("blockSize must be a positive integer.");
+    }
+    const remainder = input.length % blockSize;
+    if (remainder === 0) {
+      return input.slice();
+    }
+    const output = new Uint8Array(input.length + blockSize - remainder);
+    output.set(input);
+    return output;
+  },
+  unpad(input) {
+    let end = input.length;
+    while (end > 0 && input[end - 1] === 0) {
+      end--;
+    }
+    return input.slice(0, end);
+  }
+};
+
+// packages/classic/src/preset.ts
+import { createRegistry } from "@jscrypto/core";
+function classicPreset() {
+  return {
+    kind: "preset",
+    name: "classic",
+    components() {
+      return [
+        aes,
+        des,
+        rc4,
+        rc4Drop,
+        tripleDes,
+        cbc,
+        cfb,
+        ctr,
+        ecb,
+        gcm,
+        ofb,
+        pkcs7,
+        noPadding,
+        ansiX923,
+        iso10126,
+        iso97971,
+        zeroPadding,
+        pbkdf2,
+        evpKdf,
+        opensslFormat
+      ];
+    }
+  };
+}
+function createClassicRegistry() {
+  return createRegistry().use(classicPreset());
+}
+var registry = createClassicRegistry();
+export {
+  CryptoJS,
+  OPENSSL_SALTED_MAGIC,
+  aes,
+  ansiX923,
+  bytesToWordArray,
+  bytesToWords,
+  cbc,
+  cfb,
+  classicPreset,
+  createAesCipher,
+  createClassicRegistry,
+  createCryptoJsBlockCipher,
+  createDesCipher,
+  createRc4Transform,
+  createTripleDesCipher,
+  ctr,
+  deriveEvpKdf,
+  derivePbkdf2,
+  des,
+  ecb,
+  evpKdf,
+  gcm,
+  iso10126,
+  iso97971,
+  noPadding,
+  ofb,
+  opensslFormat,
+  pbkdf2,
+  pkcs7,
+  rc4,
+  rc4Drop,
+  registry,
+  tripleDes,
+  wordArrayToBytes,
+  wordsToBytes,
+  zeroPadding
+};
+//# sourceMappingURL=index.mjs.map