@jscrypto/classic 0.1.0 → 0.2.0

package/dist/jscrypto-classic.umd.js

@@ -1,5 +1,5 @@
 /*!
- * @jscrypto/classic v0.1.0
+ * @jscrypto/classic v0.2.0
  * Copyright 2026 Chen, Yi-Cyuan
  * Released under the MIT license
  */
@@ -7,16 +7,45 @@
 var jscryptoClassic = (() => {
   var __create = Object.create;
   var __defProp = Object.defineProperty;
+  var __defProps = Object.defineProperties;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
   var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __propIsEnum = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    if (__getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(b)) {
+        if (__propIsEnum.call(b, prop))
+          __defNormalProp(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
   var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
     get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
   }) : x)(function(x) {
     if (typeof require !== "undefined") return require.apply(this, arguments);
     throw Error('Dynamic require of "' + x + '" is not supported');
   });
+  var __objRest = (source, exclude) => {
+    var target = {};
+    for (var prop in source)
+      if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+        target[prop] = source[prop];
+    if (source != null && __getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(source)) {
+        if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+          target[prop] = source[prop];
+      }
+    return target;
+  };
   var __commonJS = (cb, mod) => function __require2() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
@@ -6701,7 +6730,7 @@ var jscryptoClassic = (() => {
     }
   };
   function createAesCipher(key) {
-    if (![16, 24, 32].includes(key.length)) {
+    if (key.length !== 16 && key.length !== 24 && key.length !== 32) {
       throw new Error("AES key must be 128, 192, or 256 bits.");
     }
     return createCryptoJsBlockCipher({
@@ -6778,10 +6807,10 @@ var jscryptoClassic = (() => {
         assertNotFinalized(finalized);
         return processInput(input);
       },
-      finalize(input = new Uint8Array()) {
+      finalize(input = new Uint8Array(0)) {
         assertNotFinalized(finalized);
         finalized = true;
-        return input.length === 0 ? new Uint8Array() : processInput(input);
+        return input.length === 0 ? new Uint8Array(0) : processInput(input);
       }
     };
   }
@@ -6846,7 +6875,7 @@ var jscryptoClassic = (() => {
     }
   };
   function createTripleDesCipher(key) {
-    if (![16, 24].includes(key.length)) {
+    if (key.length !== 16 && key.length !== 24) {
       throw new Error("Triple DES key must be 128 or 192 bits.");
     }
     return createCryptoJsBlockCipher({
@@ -6906,6 +6935,11 @@ var jscryptoClassic = (() => {
     }
     return output;
   }
+  function assertBytes(value, name) {
+    if (!(value instanceof Uint8Array)) {
+      throw new TypeError(`${name} must be a Uint8Array.`);
+    }
+  }
 
   // packages/core/src/passphrase.ts
   function createPassphraseCipher(registry2, options) {
@@ -6925,8 +6959,9 @@ var jscryptoClassic = (() => {
     };
   }
   function createPassphraseEncryptor(registry2, options) {
+    var _a;
     const format = resolveFormat(registry2, options);
-    const salt = options.salt ? options.salt.slice() : randomBytes(options.saltSize ?? 8);
+    const salt = options.salt ? options.salt.slice() : randomBytes((_a = options.saltSize) != null ? _a : 8);
     const { key, iv } = deriveKeyIv(registry2, options, salt);
     const encryptor = registry2.createCipher(toTransformOptions(options, key, iv)).createEncryptor();
     if (!format) {
@@ -6938,16 +6973,16 @@ var jscryptoClassic = (() => {
     let emittedHeader = false;
     const emitHeader = () => {
       if (emittedHeader) {
-        return new Uint8Array();
+        return new Uint8Array(0);
       }
       emittedHeader = true;
-      return format.stringify({ ciphertext: new Uint8Array(), salt });
+      return format.stringify({ ciphertext: new Uint8Array(0), salt });
     };
     return {
       process(input) {
         return concatBytes(emitHeader(), encryptor.process(input));
       },
-      finalize(input = new Uint8Array()) {
+      finalize(input = new Uint8Array(0)) {
         return concatBytes(emitHeader(), encryptor.finalize(input));
       }
     };
@@ -6955,43 +6990,44 @@ var jscryptoClassic = (() => {
   function createPassphraseDecryptor(registry2, options) {
     const format = resolveFormat(registry2, options);
     if (!format) {
-      const { key, iv } = deriveKeyIv(registry2, options, new Uint8Array());
+      const { key, iv } = deriveKeyIv(registry2, options, new Uint8Array(0));
       return registry2.createCipher(toTransformOptions(options, key, iv)).createDecryptor();
     }
     if (!isStreamingOpenSslFormat(format)) {
       return createBufferedFormatDecryptor(registry2, options, format);
     }
-    let header = new Uint8Array();
+    let header = new Uint8Array(0);
     let decryptor;
     const initDecryptor = (input) => {
+      var _a;
       if (decryptor) {
         return input;
       }
       header = new Uint8Array(concatBytes(header, input));
       if (header.length < 16) {
-        return new Uint8Array();
+        return new Uint8Array(0);
       }
       const parsed = format.parse(header.slice(0, 16));
       const hasSalt = parsed.salt !== void 0;
-      const salt = parsed.salt ?? new Uint8Array();
+      const salt = (_a = parsed.salt) != null ? _a : new Uint8Array(0);
       const ciphertext = hasSalt ? concatBytes(parsed.ciphertext, header.slice(16)) : header;
       const { key, iv } = deriveKeyIv(registry2, options, salt);
       decryptor = registry2.createCipher(toTransformOptions(options, key, iv)).createDecryptor();
-      header = new Uint8Array();
+      header = new Uint8Array(0);
       return ciphertext;
     };
     return {
       process(input) {
         const ciphertext = initDecryptor(input);
-        return decryptor ? decryptor.process(ciphertext) : new Uint8Array();
+        return decryptor ? decryptor.process(ciphertext) : new Uint8Array(0);
       },
-      finalize(input = new Uint8Array()) {
+      finalize(input = new Uint8Array(0)) {
         const ciphertext = initDecryptor(input);
         if (!decryptor) {
-          const { key, iv } = deriveKeyIv(registry2, options, new Uint8Array());
+          const { key, iv } = deriveKeyIv(registry2, options, new Uint8Array(0));
           decryptor = registry2.createCipher(toTransformOptions(options, key, iv)).createDecryptor();
           const buffered = header;
-          header = new Uint8Array();
+          header = new Uint8Array(0);
           return decryptor.finalize(buffered);
         }
         return decryptor.finalize(ciphertext);
@@ -7006,9 +7042,9 @@ var jscryptoClassic = (() => {
         if (output.length !== 0) {
           chunks.push(output);
         }
-        return new Uint8Array();
+        return new Uint8Array(0);
       },
-      finalize(input = new Uint8Array()) {
+      finalize(input = new Uint8Array(0)) {
         const output = encryptor.finalize(input);
         if (output.length !== 0) {
           chunks.push(output);
@@ -7024,14 +7060,15 @@ var jscryptoClassic = (() => {
         if (input.length !== 0) {
           chunks.push(input);
         }
-        return new Uint8Array();
+        return new Uint8Array(0);
       },
-      finalize(input = new Uint8Array()) {
+      finalize(input = new Uint8Array(0)) {
+        var _a;
         if (input.length !== 0) {
           chunks.push(input);
         }
         const parsed = format.parse(concatBytes(...chunks));
-        const { key, iv } = deriveKeyIv(registry2, options, parsed.salt ?? new Uint8Array());
+        const { key, iv } = deriveKeyIv(registry2, options, (_a = parsed.salt) != null ? _a : new Uint8Array(0));
         return registry2.createCipher(toTransformOptions(options, key, iv)).decrypt(parsed.ciphertext);
       }
     };
@@ -7048,33 +7085,37 @@ var jscryptoClassic = (() => {
   function deriveSync(registry2, options, salt, length) {
     const kdfOptions = normalizeNamedOptions(options.kdf);
     const kdf = registry2.get("kdf", kdfOptions.name);
-    const result = kdf.derive({
-      ...withoutName(kdfOptions),
+    const result = kdf.derive(__spreadProps(__spreadValues({}, withoutName(kdfOptions)), {
       passphrase: options.passphrase,
       salt,
       length
-    });
+    }));
     if (result instanceof Promise) {
       throw new Error(`KDF ${kdfOptions.name} is asynchronous; use an async passphrase cipher API.`);
     }
     return result;
   }
   function toTransformOptions(options, key, iv) {
-    const {
+    const _a = options, {
       passphrase,
       kdf,
       format,
       salt,
       saltSize,
       keySize,
-      ivSize,
-      ...transformOptions
-    } = options;
-    return {
-      ...transformOptions,
-      key,
-      ...iv ? { iv } : {}
-    };
+      ivSize
+    } = _a, transformOptions = __objRest(_a, [
+      "passphrase",
+      "kdf",
+      "format",
+      "salt",
+      "saltSize",
+      "keySize",
+      "ivSize"
+    ]);
+    return __spreadValues(__spreadProps(__spreadValues({}, transformOptions), {
+      key
+    }), iv ? { iv } : {});
   }
   function resolveKeySize(registry2, options) {
     if (options.keySize !== void 0) {
@@ -7108,17 +7149,18 @@ var jscryptoClassic = (() => {
     return typeof options === "string" ? { name: options } : options;
   }
   function withoutName(options) {
-    const { name, ...rest } = options;
+    const _a = options, { name } = _a, rest = __objRest(_a, ["name"]);
     return rest;
   }
   function randomBytes(length) {
+    var _a;
     assertNonNegativeInteger(length, "saltSize");
     const bytes = new Uint8Array(length);
     if (bytes.length === 0) {
       return bytes;
     }
     const crypto = globalThis;
-    crypto.crypto?.getRandomValues(bytes);
+    (_a = crypto.crypto) == null ? void 0 : _a.getRandomValues(bytes);
     if (bytes.some((byte) => byte !== 0)) {
       return bytes;
     }
@@ -7151,27 +7193,29 @@ var jscryptoClassic = (() => {
     const blockCipher = cipher.create(options.key);
     const modeEncryptor = mode.createEncryptor({
       cipher: blockCipher,
-      iv: options.iv
+      iv: options.iv,
+      options
     });
     if (mode.requiresPadding === false) {
       return createStreamEncryptor(modeEncryptor);
     }
+    const blockPadding = padding;
     let finalized = false;
-    let pending = new Uint8Array();
+    let pending = new Uint8Array(0);
     return {
       process(input) {
         assertNotFinalized2(finalized);
         const data = concatBytes(pending, input);
         const processLength = data.length - data.length % blockCipher.blockSize;
         pending = data.slice(processLength);
-        return processLength === 0 ? new Uint8Array() : modeEncryptor.process(data.subarray(0, processLength));
+        return processLength === 0 ? new Uint8Array(0) : modeEncryptor.process(data.subarray(0, processLength));
       },
-      finalize(input = new Uint8Array()) {
+      finalize(input = new Uint8Array(0)) {
         assertNotFinalized2(finalized);
-        const processed = input.length === 0 ? new Uint8Array() : this.process(input);
+        const processed = input.length === 0 ? new Uint8Array(0) : this.process(input);
         finalized = true;
-        const finalBlock = padding.pad(pending, blockCipher.blockSize);
-        pending = new Uint8Array();
+        const finalBlock = blockPadding.pad(pending, blockCipher.blockSize);
+        pending = new Uint8Array(0);
         return concatBytes(processed, modeEncryptor.finalize(finalBlock));
       }
     };
@@ -7188,14 +7232,16 @@ var jscryptoClassic = (() => {
     const blockCipher = cipher.create(options.key);
     const modeDecryptor = mode.createDecryptor({
       cipher: blockCipher,
-      iv: options.iv
+      iv: options.iv,
+      options
     });
     if (mode.requiresPadding === false) {
       return createStreamDecryptor(modeDecryptor);
     }
+    const blockPadding = padding;
     let finalized = false;
-    let pending = new Uint8Array();
-    let plaintextPending = new Uint8Array();
+    let pending = new Uint8Array(0);
+    let plaintextPending = new Uint8Array(0);
     return {
       process(input) {
         assertNotFinalized2(finalized);
@@ -7203,23 +7249,23 @@ var jscryptoClassic = (() => {
         const processLength = data.length - data.length % blockCipher.blockSize;
         pending = data.slice(processLength);
         if (processLength === 0) {
-          return new Uint8Array();
+          return new Uint8Array(0);
         }
         const decrypted = modeDecryptor.process(data.subarray(0, processLength));
         const output = plaintextPending;
         plaintextPending = decrypted;
         return output;
       },
-      finalize(input = new Uint8Array()) {
+      finalize(input = new Uint8Array(0)) {
         assertNotFinalized2(finalized);
-        const processed = input.length === 0 ? new Uint8Array() : this.process(input);
+        const processed = input.length === 0 ? new Uint8Array(0) : this.process(input);
         finalized = true;
         if (pending.length !== 0) {
-          padding.unpad(pending, blockCipher.blockSize);
+          blockPadding.unpad(pending, blockCipher.blockSize);
         }
-        const finalPlaintext = padding.unpad(plaintextPending, blockCipher.blockSize);
-        pending = new Uint8Array();
-        plaintextPending = new Uint8Array();
+        const finalPlaintext = blockPadding.unpad(plaintextPending, blockCipher.blockSize);
+        pending = new Uint8Array(0);
+        plaintextPending = new Uint8Array(0);
         return concatBytes(processed, finalPlaintext, modeDecryptor.finalize());
       }
     };
@@ -7231,11 +7277,11 @@ var jscryptoClassic = (() => {
         assertNotFinalized2(finalized);
         return modeEncryptor.process(input);
       },
-      finalize(input = new Uint8Array()) {
+      finalize(input = new Uint8Array(0)) {
         assertNotFinalized2(finalized);
         finalized = true;
         return concatBytes(
-          input.length === 0 ? new Uint8Array() : modeEncryptor.process(input),
+          input.length === 0 ? new Uint8Array(0) : modeEncryptor.process(input),
           modeEncryptor.finalize()
         );
       }
@@ -7248,11 +7294,11 @@ var jscryptoClassic = (() => {
         assertNotFinalized2(finalized);
         return modeDecryptor.process(input);
       },
-      finalize(input = new Uint8Array()) {
+      finalize(input = new Uint8Array(0)) {
         assertNotFinalized2(finalized);
         finalized = true;
         return concatBytes(
-          input.length === 0 ? new Uint8Array() : modeDecryptor.process(input),
+          input.length === 0 ? new Uint8Array(0) : modeDecryptor.process(input),
           modeDecryptor.finalize()
         );
       }
@@ -7262,13 +7308,18 @@ var jscryptoClassic = (() => {
     if (!options.mode) {
       throw new Error(`${options.cipher} block cipher requires a mode.`);
     }
-    if (!options.padding) {
-      throw new Error(`${options.cipher} block cipher requires padding.`);
+    const mode = registry2.get("mode", options.mode);
+    let padding;
+    if (mode.requiresPadding !== false) {
+      if (!options.padding) {
+        throw new Error(`${options.cipher} block cipher requires padding.`);
+      }
+      padding = registry2.get("padding", options.padding);
     }
     return {
       cipher: registry2.get("cipher", options.cipher),
-      mode: registry2.get("mode", options.mode),
-      padding: registry2.get("padding", options.padding)
+      mode,
+      padding
     };
   }
   function assertNotFinalized2(finalized) {
@@ -7433,13 +7484,14 @@ var jscryptoClassic = (() => {
     }
   };
   function deriveEvpKdf(params) {
+    var _a;
     assertPositiveInteger2(params.length, "EvpKDF length");
     if (params.iterations !== void 0) {
       assertPositiveInteger2(params.iterations, "EvpKDF iterations");
     }
     const options = {
       keySize: params.length / 4,
-      iterations: params.iterations ?? 1
+      iterations: (_a = params.iterations) != null ? _a : 1
     };
     const hasher = getHasher(params.hash);
     if (hasher) {
@@ -7462,7 +7514,7 @@ var jscryptoClassic = (() => {
     return hasher;
   }
   function normalizeHashName(hash) {
-    return hash.replaceAll("-", "").toUpperCase();
+    return hash.replace(/-/g, "").toUpperCase();
   }
   function assertPositiveInteger2(value, label) {
     if (!Number.isInteger(value) || value <= 0) {
@@ -7506,7 +7558,7 @@ var jscryptoClassic = (() => {
     return hasher;
   }
   function normalizeHashName2(hash) {
-    return hash.replaceAll("-", "").toUpperCase();
+    return hash.replace(/-/g, "").toUpperCase();
   }
   function assertPositiveInteger3(value, label) {
     if (!Number.isInteger(value) || value <= 0) {
@@ -7542,8 +7594,8 @@ var jscryptoClassic = (() => {
         }
         return output;
       },
-      finalize(input = new Uint8Array()) {
-        return input.length === 0 ? new Uint8Array() : this.process(input);
+      finalize(input = new Uint8Array(0)) {
+        return input.length === 0 ? new Uint8Array(0) : this.process(input);
       }
     };
   }
@@ -7561,8 +7613,8 @@ var jscryptoClassic = (() => {
         }
         return output;
       },
-      finalize(input = new Uint8Array()) {
-        return input.length === 0 ? new Uint8Array() : this.process(input);
+      finalize(input = new Uint8Array(0)) {
+        return input.length === 0 ? new Uint8Array(0) : this.process(input);
       }
     };
   }
@@ -7615,8 +7667,8 @@ var jscryptoClassic = (() => {
         }
         return output;
       },
-      finalize(input = new Uint8Array()) {
-        return input.length === 0 ? new Uint8Array() : this.process(input);
+      finalize(input = new Uint8Array(0)) {
+        return input.length === 0 ? new Uint8Array(0) : this.process(input);
       }
     };
   }
@@ -7653,8 +7705,8 @@ var jscryptoClassic = (() => {
         }
         return output;
       },
-      finalize(input = new Uint8Array()) {
-        return input.length === 0 ? new Uint8Array() : this.process(input);
+      finalize(input = new Uint8Array(0)) {
+        return input.length === 0 ? new Uint8Array(0) : this.process(input);
       }
     };
   }
@@ -7689,8 +7741,8 @@ var jscryptoClassic = (() => {
         }
         return output;
       },
-      finalize(input = new Uint8Array()) {
-        return input.length === 0 ? new Uint8Array() : this.process(input);
+      finalize(input = new Uint8Array(0)) {
+        return input.length === 0 ? new Uint8Array(0) : this.process(input);
       }
     };
   }
@@ -7704,8 +7756,8 @@ var jscryptoClassic = (() => {
         }
         return output;
       },
-      finalize(input = new Uint8Array()) {
-        return input.length === 0 ? new Uint8Array() : this.process(input);
+      finalize(input = new Uint8Array(0)) {
+        return input.length === 0 ? new Uint8Array(0) : this.process(input);
       }
     };
   }
@@ -7720,13 +7772,291 @@ var jscryptoClassic = (() => {
     aead: true,
     requiredBlockSize: 16,
     requiresPadding: false,
-    createEncryptor() {
-      throw new Error("GCM mode is not implemented yet.");
+    createEncryptor({ cipher, iv, options }) {
+      return createGcmEncryptor(cipher, getNonce(iv, options), getAad(options), getTagLength(options));
     },
-    createDecryptor() {
-      throw new Error("GCM mode is not implemented yet.");
+    createDecryptor({ cipher, iv, options }) {
+      return createGcmDecryptor(cipher, getNonce(iv, options), getAad(options), getTagLength(options), getTag(options));
     }
   };
+  var BLOCK_SIZE = 16;
+  var DEFAULT_TAG_LENGTH = 16;
+  var R_WORD = 3774873600;
+  function createGcmEncryptor(cipher, nonce, aad, tagLength) {
+    assertGcmCipher(cipher);
+    const auth = createGhash(cipher.encryptBlock(new Uint8Array(BLOCK_SIZE)));
+    auth.update(aad);
+    auth.pad();
+    const j0 = createInitialCounter(auth.h, nonce);
+    const tagMask = cipher.encryptBlock(j0);
+    const counter = j0.slice();
+    incrementCounter2(counter);
+    const xor = createCounterXor(cipher, counter);
+    let ciphertextLength = 0;
+    return {
+      process(input) {
+        const ciphertext = xor(input);
+        auth.update(ciphertext);
+        ciphertextLength += ciphertext.length;
+        return ciphertext;
+      },
+      finalize(input = new Uint8Array(0)) {
+        const ciphertext = input.length === 0 ? new Uint8Array(0) : this.process(input);
+        const tag = createTag(auth, tagMask, aad.length, ciphertextLength, tagLength);
+        return concatBytes(ciphertext, tag);
+      }
+    };
+  }
+  function createGcmDecryptor(cipher, nonce, aad, tagLength, detachedTag) {
+    assertGcmCipher(cipher);
+    const h = cipher.encryptBlock(new Uint8Array(BLOCK_SIZE));
+    const j0 = createInitialCounter(h, nonce);
+    const tagMask = cipher.encryptBlock(j0);
+    let pending = new Uint8Array(0);
+    return {
+      process(input) {
+        pending = concatBytes(pending, input);
+        return new Uint8Array(0);
+      },
+      finalize(input = new Uint8Array(0)) {
+        if (input.length !== 0) {
+          this.process(input);
+        }
+        let ciphertext = pending;
+        let tag = detachedTag;
+        if (!tag) {
+          if (pending.length < tagLength) {
+            throw new Error("GCM ciphertext must include an authentication tag.");
+          }
+          ciphertext = new Uint8Array(pending.subarray(0, pending.length - tagLength));
+          tag = new Uint8Array(pending.subarray(pending.length - tagLength));
+        }
+        const auth = createGhash(h);
+        auth.update(aad);
+        auth.pad();
+        auth.update(ciphertext);
+        const expectedTag = createTag(auth, tagMask, aad.length, ciphertext.length, tagLength);
+        if (!equalBytes(expectedTag, tag)) {
+          throw new Error("GCM authentication failed.");
+        }
+        const counter = j0.slice();
+        incrementCounter2(counter);
+        const plaintext = createCounterXor(cipher, counter)(ciphertext);
+        pending = new Uint8Array(0);
+        return plaintext;
+      }
+    };
+  }
+  function createGhash(h) {
+    const hValue = blockToWords(h);
+    let state = createZeroWords();
+    let pending = new Uint8Array(0);
+    function updateBlock(block) {
+      state = multiplyGf128(xorWords(state, blockToWords(padBlock(block))), hValue);
+    }
+    return {
+      h,
+      update(input) {
+        const data = concatBytes(pending, input);
+        const processLength = data.length - data.length % BLOCK_SIZE;
+        for (let offset = 0; offset < processLength; offset += BLOCK_SIZE) {
+          updateBlock(data.subarray(offset, offset + BLOCK_SIZE));
+        }
+        pending = data.slice(processLength);
+      },
+      pad() {
+        if (pending.length !== 0) {
+          updateBlock(pending);
+          pending = new Uint8Array(0);
+        }
+      },
+      digest(aadLength, ciphertextLength) {
+        this.pad();
+        updateBlock(createLengthBlock(aadLength, ciphertextLength));
+        return wordsToBlock(state);
+      }
+    };
+  }
+  function createInitialCounter(h, nonce) {
+    if (nonce.length === 0) {
+      throw new Error("GCM mode requires a nonce.");
+    }
+    if (nonce.length === 12) {
+      const j0 = new Uint8Array(BLOCK_SIZE);
+      j0.set(nonce);
+      j0[15] = 1;
+      return j0;
+    }
+    const auth = createGhash(h);
+    auth.update(nonce);
+    return auth.digest(0, nonce.length);
+  }
+  function createCounterXor(cipher, counter) {
+    let keystream = new Uint8Array(0);
+    let position = BLOCK_SIZE;
+    return (input) => {
+      const output = new Uint8Array(input.length);
+      for (let i = 0; i < input.length; i++) {
+        if (position === BLOCK_SIZE) {
+          keystream = cipher.encryptBlock(counter);
+          incrementCounter2(counter);
+          position = 0;
+        }
+        output[i] = input[i] ^ keystream[position];
+        position++;
+      }
+      return output;
+    };
+  }
+  function createTag(auth, tagMask, aadLength, ciphertextLength, tagLength) {
+    const tag = auth.digest(aadLength, ciphertextLength);
+    for (let i = 0; i < tag.length; i++) {
+      tag[i] ^= tagMask[i];
+    }
+    return tag.subarray(0, tagLength);
+  }
+  function createZeroWords() {
+    return [0, 0, 0, 0];
+  }
+  function multiplyGf128(x, y) {
+    const z = createZeroWords();
+    const v = [y[0], y[1], y[2], y[3]];
+    for (let i = 0; i < 128; i++) {
+      if ((x[i >>> 5] & 2147483648 >>> (i & 31)) !== 0) {
+        xorWordsInPlace(z, v);
+      }
+      shiftRightAndReduce(v);
+    }
+    return z;
+  }
+  function shiftRightAndReduce(words) {
+    const lsb = words[3] & 1;
+    words[3] = (words[3] >>> 1 | (words[2] & 1) << 31) >>> 0;
+    words[2] = (words[2] >>> 1 | (words[1] & 1) << 31) >>> 0;
+    words[1] = (words[1] >>> 1 | (words[0] & 1) << 31) >>> 0;
+    words[0] >>>= 1;
+    if (lsb) {
+      words[0] = (words[0] ^ R_WORD) >>> 0;
+    }
+  }
+  function xorWords(left, right) {
+    return [
+      (left[0] ^ right[0]) >>> 0,
+      (left[1] ^ right[1]) >>> 0,
+      (left[2] ^ right[2]) >>> 0,
+      (left[3] ^ right[3]) >>> 0
+    ];
+  }
+  function xorWordsInPlace(left, right) {
+    left[0] = (left[0] ^ right[0]) >>> 0;
+    left[1] = (left[1] ^ right[1]) >>> 0;
+    left[2] = (left[2] ^ right[2]) >>> 0;
+    left[3] = (left[3] ^ right[3]) >>> 0;
+  }
+  function incrementCounter2(counter) {
+    const value = (counter[12] << 24 >>> 0 | counter[13] << 16 | counter[14] << 8 | counter[15]) + 1 >>> 0;
+    counter[12] = value >>> 24;
+    counter[13] = value >>> 16;
+    counter[14] = value >>> 8;
+    counter[15] = value;
+  }
+  function padBlock(input) {
+    if (input.length === BLOCK_SIZE) {
+      return input;
+    }
+    const output = new Uint8Array(BLOCK_SIZE);
+    output.set(input);
+    return output;
+  }
+  function createLengthBlock(aadLength, ciphertextLength) {
+    const output = new Uint8Array(BLOCK_SIZE);
+    writeBitLength64BE(aadLength, output, 0);
+    writeBitLength64BE(ciphertextLength, output, 8);
+    return output;
+  }
+  function writeBitLength64BE(byteLength, output, offset) {
+    const high = Math.floor(byteLength / 536870912);
+    const low = byteLength % 536870912 * 8;
+    writeUint32BE(high, output, offset);
+    writeUint32BE(low, output, offset + 4);
+  }
+  function blockToWords(input) {
+    return [
+      readUint32BE(input, 0),
+      readUint32BE(input, 4),
+      readUint32BE(input, 8),
+      readUint32BE(input, 12)
+    ];
+  }
+  function wordsToBlock(words) {
+    const output = new Uint8Array(BLOCK_SIZE);
+    writeUint32BE(words[0], output, 0);
+    writeUint32BE(words[1], output, 4);
+    writeUint32BE(words[2], output, 8);
+    writeUint32BE(words[3], output, 12);
+    return output;
+  }
+  function readUint32BE(input, offset) {
+    return (input[offset] << 24 >>> 0 | input[offset + 1] << 16 | input[offset + 2] << 8 | input[offset + 3]) >>> 0;
+  }
+  function writeUint32BE(value, output, offset) {
+    output[offset] = value >>> 24;
+    output[offset + 1] = value >>> 16;
+    output[offset + 2] = value >>> 8;
+    output[offset + 3] = value;
+  }
+  function getNonce(iv, options) {
+    const nonce = getOptions(options).nonce;
+    if (nonce !== void 0) {
+      assertBytes(nonce, "GCM nonce");
+      if (iv !== void 0) {
+        throw new Error("GCM mode accepts either iv or nonce, not both.");
+      }
+      return nonce;
+    }
+    if (!iv) {
+      throw new Error("GCM mode requires an IV/nonce.");
+    }
+    return iv;
+  }
+  function getAad(options) {
+    const aad = getOptions(options).aad;
+    if (aad === void 0) {
+      return new Uint8Array(0);
+    }
+    assertBytes(aad, "GCM aad");
+    return aad;
+  }
+  function getTag(options) {
+    const tag = getOptions(options).tag;
+    if (tag === void 0) {
+      return void 0;
+    }
+    assertBytes(tag, "GCM tag");
+    return tag;
+  }
+  function getTagLength(options) {
+    const tag = getTag(options);
+    if (tag) {
+      return tag.length;
+    }
+    const tagLength = getOptions(options).tagLength;
+    if (tagLength === void 0) {
+      return DEFAULT_TAG_LENGTH;
+    }
+    if (typeof tagLength !== "number" || !Number.isInteger(tagLength) || tagLength < 4 || tagLength > BLOCK_SIZE) {
+      throw new RangeError("GCM tagLength must be an integer between 4 and 16 bytes.");
+    }
+    return tagLength;
+  }
+  function getOptions(options) {
+    return typeof options === "object" && options !== null ? options : {};
+  }
+  function assertGcmCipher(cipher) {
+    if (cipher.blockSize !== BLOCK_SIZE) {
+      throw new Error("GCM mode requires a 128-bit block cipher.");
+    }
+  }
 
   // packages/classic/src/modes/ofb.ts
   var ofb = {
@@ -7760,8 +8090,8 @@ var jscryptoClassic = (() => {
         }
         return output;
       },
-      finalize(input = new Uint8Array()) {
-        return input.length === 0 ? new Uint8Array() : this.process(input);
+      finalize(input = new Uint8Array(0)) {
+        return input.length === 0 ? new Uint8Array(0) : this.process(input);
       }
     };
   }
@@ -7834,11 +8164,12 @@ var jscryptoClassic = (() => {
     return getBlockPaddingLength(inputLength, blockSize);
   }
   function fillRandom(bytes) {
+    var _a;
     if (bytes.length === 0) {
       return;
     }
     const crypto = globalThis;
-    crypto.crypto?.getRandomValues(bytes);
+    (_a = crypto.crypto) == null ? void 0 : _a.getRandomValues(bytes);
     if (bytes.some((byte) => byte !== 0)) {
       return;
     }