@jscrypto/classic 0.1.0

package/dist/index.cjs

@@ -0,0 +1,948 @@
+/*!
+ * @jscrypto/classic v0.1.0
+ * Copyright 2026 Chen, Yi-Cyuan
+ * Released under the MIT license
+ */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/classic/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CryptoJS: () => import_crypto_js.default,
+  OPENSSL_SALTED_MAGIC: () => OPENSSL_SALTED_MAGIC,
+  aes: () => aes,
+  ansiX923: () => ansiX923,
+  bytesToWordArray: () => bytesToWordArray,
+  bytesToWords: () => bytesToWords,
+  cbc: () => cbc,
+  cfb: () => cfb,
+  classicPreset: () => classicPreset,
+  createAesCipher: () => createAesCipher,
+  createClassicRegistry: () => createClassicRegistry,
+  createCryptoJsBlockCipher: () => createCryptoJsBlockCipher,
+  createDesCipher: () => createDesCipher,
+  createRc4Transform: () => createRc4Transform,
+  createTripleDesCipher: () => createTripleDesCipher,
+  ctr: () => ctr,
+  deriveEvpKdf: () => deriveEvpKdf,
+  derivePbkdf2: () => derivePbkdf2,
+  des: () => des,
+  ecb: () => ecb,
+  evpKdf: () => evpKdf,
+  gcm: () => gcm,
+  iso10126: () => iso10126,
+  iso97971: () => iso97971,
+  noPadding: () => noPadding,
+  ofb: () => ofb,
+  opensslFormat: () => opensslFormat,
+  pbkdf2: () => pbkdf2,
+  pkcs7: () => pkcs7,
+  rc4: () => rc4,
+  rc4Drop: () => rc4Drop,
+  registry: () => registry,
+  tripleDes: () => tripleDes,
+  wordArrayToBytes: () => wordArrayToBytes,
+  wordsToBytes: () => wordsToBytes,
+  zeroPadding: () => zeroPadding
+});
+module.exports = __toCommonJS(index_exports);
+
+// packages/classic/src/adapter/crypto-js.ts
+var import_crypto_js = __toESM(require("crypto-js"), 1);
+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 import_crypto_js.default.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: import_crypto_js.default.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: import_crypto_js.default.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: import_crypto_js.default.algo.TripleDES
+  });
+}
+
+// packages/classic/src/formats/openssl.ts
+var import_core = require("@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 (0, import_core.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 && (0, import_core.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 = import_crypto_js.default.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 = import_crypto_js.default.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 = import_crypto_js.default.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 = import_crypto_js.default.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
+var import_core2 = require("@jscrypto/core");
+var cbc = {
+  kind: "mode",
+  name: "CBC",
+  requiresPadding: true,
+  createEncryptor({ cipher, iv }) {
+    (0, import_core2.assertIv)(cipher.blockSize, iv, "CBC");
+    return createCbcEncryptor(cipher, iv);
+  },
+  createDecryptor({ cipher, iv }) {
+    (0, import_core2.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 = (0, import_core2.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((0, import_core2.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) {
+  (0, import_core2.assertBlockMultiple)(input, blockSize, "CBC");
+}
+
+// packages/classic/src/modes/cfb.ts
+var import_core3 = require("@jscrypto/core");
+var cfb = {
+  kind: "mode",
+  name: "CFB",
+  requiresPadding: false,
+  createEncryptor({ cipher, iv }) {
+    (0, import_core3.assertIv)(cipher.blockSize, iv, "CFB");
+    return createCfbEncryptor(cipher, iv);
+  },
+  createDecryptor({ cipher, iv }) {
+    (0, import_core3.assertIv)(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
+var import_core4 = require("@jscrypto/core");
+var ctr = {
+  kind: "mode",
+  name: "CTR",
+  requiresPadding: false,
+  createEncryptor({ cipher, iv }) {
+    (0, import_core4.assertIv)(cipher.blockSize, iv, "CTR");
+    return createCtrTransform(cipher, iv);
+  },
+  createDecryptor({ cipher, iv }) {
+    (0, import_core4.assertIv)(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
+var import_core5 = require("@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) {
+  (0, import_core5.assertBlockMultiple)(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
+var import_core6 = require("@jscrypto/core");
+var ofb = {
+  kind: "mode",
+  name: "OFB",
+  requiresPadding: false,
+  createEncryptor({ cipher, iv }) {
+    (0, import_core6.assertIv)(cipher.blockSize, iv, "OFB");
+    return createOfbTransform(cipher, iv);
+  },
+  createDecryptor({ cipher, iv }) {
+    (0, import_core6.assertIv)(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
+var import_core7 = require("@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) {
+  (0, import_core7.assertBlockSize)(blockSize, { max: 255 });
+}
+function assertPaddedInput(input, blockSize) {
+  (0, import_core7.assertPaddedInput)(input, blockSize, "ANSI X9.23", { max: 255 });
+}
+function getPaddingLength(inputLength, blockSize) {
+  return (0, import_core7.getBlockPaddingLength)(inputLength, blockSize);
+}
+
+// packages/classic/src/paddings/iso10126.ts
+var import_core8 = require("@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) {
+  (0, import_core8.assertBlockSize)(blockSize, { max: 255 });
+}
+function assertPaddedInput2(input, blockSize) {
+  (0, import_core8.assertPaddedInput)(input, blockSize, "ISO 10126", { max: 255 });
+}
+function getPaddingLength2(inputLength, blockSize) {
+  return (0, import_core8.getBlockPaddingLength)(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
+var import_core9 = require("@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) {
+  (0, import_core9.assertBlockSize)(blockSize);
+}
+function assertPaddedInput3(input, blockSize) {
+  (0, import_core9.assertPaddedInput)(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
+var import_core10 = require("@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) {
+  (0, import_core10.assertBlockMultiple)(input, blockSize, "NoPadding");
+}
+
+// packages/classic/src/paddings/pkcs7.ts
+var import_core11 = require("@jscrypto/core");
+var pkcs7 = {
+  kind: "padding",
+  name: "Pkcs7",
+  pad(input, blockSize) {
+    (0, import_core11.assertBlockSize)(blockSize, { max: 255 });
+    const paddingLength = (0, import_core11.getBlockPaddingLength)(input.length, blockSize);
+    const output = new Uint8Array(input.length + paddingLength);
+    output.set(input);
+    output.fill(paddingLength, input.length);
+    return output;
+  },
+  unpad(input, blockSize) {
+    (0, import_core11.assertPaddedInput)(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
+var import_core12 = require("@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 (0, import_core12.createRegistry)().use(classicPreset());
+}
+var registry = createClassicRegistry();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs.map