@jscrypto/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,590 @@
+/*!
+ * @jscrypto/core v0.1.0
+ * Copyright 2026 Chen, Yi-Cyuan
+ * Released under the MIT license
+ */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/core/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CryptoError: () => CryptoError,
+  DuplicateComponentError: () => DuplicateComponentError,
+  MissingComponentError: () => MissingComponentError,
+  assertBlockMultiple: () => assertBlockMultiple,
+  assertBlockSize: () => assertBlockSize,
+  assertBytes: () => assertBytes,
+  assertIv: () => assertIv,
+  assertPaddedInput: () => assertPaddedInput,
+  concatBytes: () => concatBytes,
+  createRegistry: () => createRegistry,
+  equalBytes: () => equalBytes,
+  getBlockPaddingLength: () => getBlockPaddingLength,
+  xorBytes: () => xorBytes
+});
+module.exports = __toCommonJS(index_exports);
+
+// packages/core/src/errors.ts
+var CryptoError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var DuplicateComponentError = class extends CryptoError {
+  constructor(kind, name) {
+    super(`Component already registered: ${kind}:${name}`);
+  }
+};
+var MissingComponentError = class extends CryptoError {
+  constructor(kind, name) {
+    super(`Component not found: ${kind}:${name}`);
+  }
+};
+
+// packages/core/src/bytes.ts
+function concatBytes(...chunks) {
+  const length = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const output = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return output;
+}
+function equalBytes(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a[i] ^ b[i];
+  }
+  return diff === 0;
+}
+function xorBytes(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("XOR inputs must have the same length.");
+  }
+  const output = new Uint8Array(a.length);
+  for (let i = 0; i < a.length; i++) {
+    output[i] = a[i] ^ b[i];
+  }
+  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(registry, options) {
+  return {
+    encrypt(plaintext) {
+      return concatBytes(this.createEncryptor().finalize(plaintext));
+    },
+    decrypt(input) {
+      return concatBytes(this.createDecryptor().finalize(input));
+    },
+    createEncryptor() {
+      return createPassphraseEncryptor(registry, options);
+    },
+    createDecryptor() {
+      return createPassphraseDecryptor(registry, options);
+    }
+  };
+}
+function createPassphraseEncryptor(registry, options) {
+  const format = resolveFormat(registry, options);
+  const salt = options.salt ? options.salt.slice() : randomBytes(options.saltSize ?? 8);
+  const { key, iv } = deriveKeyIv(registry, options, salt);
+  const encryptor = registry.createCipher(toTransformOptions(options, key, iv)).createEncryptor();
+  if (!format) {
+    return encryptor;
+  }
+  if (!isStreamingOpenSslFormat(format)) {
+    return createBufferedFormatEncryptor(format, salt, encryptor);
+  }
+  let emittedHeader = false;
+  const emitHeader = () => {
+    if (emittedHeader) {
+      return new Uint8Array();
+    }
+    emittedHeader = true;
+    return format.stringify({ ciphertext: new Uint8Array(), salt });
+  };
+  return {
+    process(input) {
+      return concatBytes(emitHeader(), encryptor.process(input));
+    },
+    finalize(input = new Uint8Array()) {
+      return concatBytes(emitHeader(), encryptor.finalize(input));
+    }
+  };
+}
+function createPassphraseDecryptor(registry, options) {
+  const format = resolveFormat(registry, options);
+  if (!format) {
+    const { key, iv } = deriveKeyIv(registry, options, new Uint8Array());
+    return registry.createCipher(toTransformOptions(options, key, iv)).createDecryptor();
+  }
+  if (!isStreamingOpenSslFormat(format)) {
+    return createBufferedFormatDecryptor(registry, options, format);
+  }
+  let header = new Uint8Array();
+  let decryptor;
+  const initDecryptor = (input) => {
+    if (decryptor) {
+      return input;
+    }
+    header = new Uint8Array(concatBytes(header, input));
+    if (header.length < 16) {
+      return new Uint8Array();
+    }
+    const parsed = format.parse(header.slice(0, 16));
+    const hasSalt = parsed.salt !== void 0;
+    const salt = parsed.salt ?? new Uint8Array();
+    const ciphertext = hasSalt ? concatBytes(parsed.ciphertext, header.slice(16)) : header;
+    const { key, iv } = deriveKeyIv(registry, options, salt);
+    decryptor = registry.createCipher(toTransformOptions(options, key, iv)).createDecryptor();
+    header = new Uint8Array();
+    return ciphertext;
+  };
+  return {
+    process(input) {
+      const ciphertext = initDecryptor(input);
+      return decryptor ? decryptor.process(ciphertext) : new Uint8Array();
+    },
+    finalize(input = new Uint8Array()) {
+      const ciphertext = initDecryptor(input);
+      if (!decryptor) {
+        const { key, iv } = deriveKeyIv(registry, options, new Uint8Array());
+        decryptor = registry.createCipher(toTransformOptions(options, key, iv)).createDecryptor();
+        const buffered = header;
+        header = new Uint8Array();
+        return decryptor.finalize(buffered);
+      }
+      return decryptor.finalize(ciphertext);
+    }
+  };
+}
+function createBufferedFormatEncryptor(format, salt, encryptor) {
+  const chunks = [];
+  return {
+    process(input) {
+      const output = encryptor.process(input);
+      if (output.length !== 0) {
+        chunks.push(output);
+      }
+      return new Uint8Array();
+    },
+    finalize(input = new Uint8Array()) {
+      const output = encryptor.finalize(input);
+      if (output.length !== 0) {
+        chunks.push(output);
+      }
+      return format.stringify({ ciphertext: concatBytes(...chunks), salt });
+    }
+  };
+}
+function createBufferedFormatDecryptor(registry, options, format) {
+  const chunks = [];
+  return {
+    process(input) {
+      if (input.length !== 0) {
+        chunks.push(input);
+      }
+      return new Uint8Array();
+    },
+    finalize(input = new Uint8Array()) {
+      if (input.length !== 0) {
+        chunks.push(input);
+      }
+      const parsed = format.parse(concatBytes(...chunks));
+      const { key, iv } = deriveKeyIv(registry, options, parsed.salt ?? new Uint8Array());
+      return registry.createCipher(toTransformOptions(options, key, iv)).decrypt(parsed.ciphertext);
+    }
+  };
+}
+function deriveKeyIv(registry, options, salt) {
+  const keySize = resolveKeySize(registry, options);
+  const ivSize = resolveIvSize(registry, options);
+  const derived = deriveSync(registry, options, salt, keySize + ivSize);
+  return {
+    key: derived.slice(0, keySize),
+    iv: ivSize === 0 ? void 0 : derived.slice(keySize, keySize + ivSize)
+  };
+}
+function deriveSync(registry, options, salt, length) {
+  const kdfOptions = normalizeNamedOptions(options.kdf);
+  const kdf = registry.get("kdf", kdfOptions.name);
+  const result = kdf.derive({
+    ...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 {
+    passphrase,
+    kdf,
+    format,
+    salt,
+    saltSize,
+    keySize,
+    ivSize,
+    ...transformOptions
+  } = options;
+  return {
+    ...transformOptions,
+    key,
+    ...iv ? { iv } : {}
+  };
+}
+function resolveKeySize(registry, options) {
+  if (options.keySize !== void 0) {
+    assertPositiveInteger(options.keySize, "keySize");
+    return options.keySize;
+  }
+  const cipher = registry.get("cipher", options.cipher);
+  if (!cipher.keySizes || cipher.keySizes.length === 0) {
+    throw new Error(`${options.cipher} passphrase cipher requires keySize.`);
+  }
+  return Math.max(...cipher.keySizes);
+}
+function resolveIvSize(registry, options) {
+  if (options.ivSize !== void 0) {
+    assertNonNegativeInteger(options.ivSize, "ivSize");
+    return options.ivSize;
+  }
+  const cipher = registry.get("cipher", options.cipher);
+  return cipher.type === "block" ? cipher.blockSize : 0;
+}
+function resolveFormat(registry, options) {
+  if (!options.format) {
+    return void 0;
+  }
+  return registry.get("format", normalizeNamedOptions(options.format).name);
+}
+function isStreamingOpenSslFormat(format) {
+  return format.name === "OpenSSL";
+}
+function normalizeNamedOptions(options) {
+  return typeof options === "string" ? { name: options } : options;
+}
+function withoutName(options) {
+  const { name, ...rest } = options;
+  return rest;
+}
+function randomBytes(length) {
+  assertNonNegativeInteger(length, "saltSize");
+  const bytes = new Uint8Array(length);
+  if (bytes.length === 0) {
+    return bytes;
+  }
+  const crypto = globalThis;
+  crypto.crypto?.getRandomValues(bytes);
+  if (bytes.some((byte) => byte !== 0)) {
+    return bytes;
+  }
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return bytes;
+}
+function assertPositiveInteger(value, label) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new RangeError(`${label} must be a positive integer.`);
+  }
+}
+function assertNonNegativeInteger(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new RangeError(`${label} must be a non-negative integer.`);
+  }
+}
+
+// packages/core/src/transform.ts
+function createEncryptor(registry, options) {
+  const cipher = registry.get("cipher", options.cipher);
+  if (cipher.type === "stream") {
+    return createStreamEncryptor(cipher.createEncryptor({
+      key: options.key,
+      options
+    }));
+  }
+  const { mode, padding } = resolveBlockOptions(registry, options);
+  const blockCipher = cipher.create(options.key);
+  const modeEncryptor = mode.createEncryptor({
+    cipher: blockCipher,
+    iv: options.iv
+  });
+  if (mode.requiresPadding === false) {
+    return createStreamEncryptor(modeEncryptor);
+  }
+  let finalized = false;
+  let pending = new Uint8Array();
+  return {
+    process(input) {
+      assertNotFinalized(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));
+    },
+    finalize(input = new Uint8Array()) {
+      assertNotFinalized(finalized);
+      const processed = input.length === 0 ? new Uint8Array() : this.process(input);
+      finalized = true;
+      const finalBlock = padding.pad(pending, blockCipher.blockSize);
+      pending = new Uint8Array();
+      return concatBytes(processed, modeEncryptor.finalize(finalBlock));
+    }
+  };
+}
+function createDecryptor(registry, options) {
+  const cipher = registry.get("cipher", options.cipher);
+  if (cipher.type === "stream") {
+    return createStreamDecryptor(cipher.createDecryptor({
+      key: options.key,
+      options
+    }));
+  }
+  const { mode, padding } = resolveBlockOptions(registry, options);
+  const blockCipher = cipher.create(options.key);
+  const modeDecryptor = mode.createDecryptor({
+    cipher: blockCipher,
+    iv: options.iv
+  });
+  if (mode.requiresPadding === false) {
+    return createStreamDecryptor(modeDecryptor);
+  }
+  let finalized = false;
+  let pending = new Uint8Array();
+  let plaintextPending = new Uint8Array();
+  return {
+    process(input) {
+      assertNotFinalized(finalized);
+      const data = concatBytes(pending, input);
+      const processLength = data.length - data.length % blockCipher.blockSize;
+      pending = data.slice(processLength);
+      if (processLength === 0) {
+        return new Uint8Array();
+      }
+      const decrypted = modeDecryptor.process(data.subarray(0, processLength));
+      const output = plaintextPending;
+      plaintextPending = decrypted;
+      return output;
+    },
+    finalize(input = new Uint8Array()) {
+      assertNotFinalized(finalized);
+      const processed = input.length === 0 ? new Uint8Array() : this.process(input);
+      finalized = true;
+      if (pending.length !== 0) {
+        padding.unpad(pending, blockCipher.blockSize);
+      }
+      const finalPlaintext = padding.unpad(plaintextPending, blockCipher.blockSize);
+      pending = new Uint8Array();
+      plaintextPending = new Uint8Array();
+      return concatBytes(processed, finalPlaintext, modeDecryptor.finalize());
+    }
+  };
+}
+function createStreamEncryptor(modeEncryptor) {
+  let finalized = false;
+  return {
+    process(input) {
+      assertNotFinalized(finalized);
+      return modeEncryptor.process(input);
+    },
+    finalize(input = new Uint8Array()) {
+      assertNotFinalized(finalized);
+      finalized = true;
+      return concatBytes(
+        input.length === 0 ? new Uint8Array() : modeEncryptor.process(input),
+        modeEncryptor.finalize()
+      );
+    }
+  };
+}
+function createStreamDecryptor(modeDecryptor) {
+  let finalized = false;
+  return {
+    process(input) {
+      assertNotFinalized(finalized);
+      return modeDecryptor.process(input);
+    },
+    finalize(input = new Uint8Array()) {
+      assertNotFinalized(finalized);
+      finalized = true;
+      return concatBytes(
+        input.length === 0 ? new Uint8Array() : modeDecryptor.process(input),
+        modeDecryptor.finalize()
+      );
+    }
+  };
+}
+function resolveBlockOptions(registry, options) {
+  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.`);
+  }
+  return {
+    cipher: registry.get("cipher", options.cipher),
+    mode: registry.get("mode", options.mode),
+    padding: registry.get("padding", options.padding)
+  };
+}
+function assertNotFinalized(finalized) {
+  if (finalized) {
+    throw new Error("Transform is already finalized.");
+  }
+}
+
+// packages/core/src/registry.ts
+function createRegistry(components = []) {
+  const entries = /* @__PURE__ */ new Map();
+  const key = (kind, name) => `${kind}:${name}`;
+  const registry = {
+    use(component) {
+      if (component.kind === "preset") {
+        for (const item of component.components()) {
+          registry.use(item);
+        }
+        return registry;
+      }
+      const entryKey = key(component.kind, component.name);
+      if (entries.has(entryKey)) {
+        throw new DuplicateComponentError(component.kind, component.name);
+      }
+      entries.set(entryKey, component);
+      return registry;
+    },
+    has(kind, name) {
+      return entries.has(key(kind, name));
+    },
+    get(kind, name) {
+      const component = entries.get(key(kind, name));
+      if (!component) {
+        throw new MissingComponentError(kind, name);
+      }
+      return component;
+    },
+    list(kind) {
+      const components2 = [...entries.values()];
+      return kind ? components2.filter((component) => component.kind === kind) : components2;
+    },
+    createCipher(options) {
+      return {
+        encrypt(plaintext) {
+          return createEncryptor(registry, options).finalize(plaintext);
+        },
+        decrypt(ciphertext) {
+          return createDecryptor(registry, options).finalize(ciphertext);
+        },
+        createEncryptor() {
+          return createEncryptor(registry, options);
+        },
+        createDecryptor() {
+          return createDecryptor(registry, options);
+        }
+      };
+    },
+    createPassphraseCipher(options) {
+      return createPassphraseCipher(registry, options);
+    },
+    encrypt(options) {
+      return createEncryptor(registry, options).finalize(options.plaintext);
+    },
+    decrypt(options) {
+      return createDecryptor(registry, options).finalize(options.ciphertext);
+    },
+    createEncryptor(options) {
+      return createEncryptor(registry, options);
+    },
+    createDecryptor(options) {
+      return createDecryptor(registry, options);
+    }
+  };
+  for (const component of components) {
+    registry.use(component);
+  }
+  return registry;
+}
+
+// packages/core/src/blocks.ts
+function assertBlockSize(blockSize, options = {}) {
+  const { max } = options;
+  if (!Number.isInteger(blockSize) || blockSize <= 0) {
+    throw new RangeError("blockSize must be a positive integer.");
+  }
+  if (max !== void 0 && blockSize > max) {
+    throw new RangeError(`blockSize must be an integer between 1 and ${max}.`);
+  }
+}
+function assertBlockMultiple(input, blockSize, label) {
+  assertBlockSize(blockSize);
+  if (input.length % blockSize !== 0) {
+    throw new Error(`${label} input length must be a multiple of the block size.`);
+  }
+}
+function assertPaddedInput(input, blockSize, label, options = {}) {
+  assertBlockSize(blockSize, options);
+  if (input.length === 0 || input.length % blockSize !== 0) {
+    throw new Error(`Invalid ${label} padded data.`);
+  }
+}
+function assertIv(blockSize, iv, modeName) {
+  if (!iv) {
+    throw new Error(`${modeName} mode requires an IV.`);
+  }
+  if (iv.length !== blockSize) {
+    throw new Error(`${modeName} IV length must match the cipher block size.`);
+  }
+}
+function getBlockPaddingLength(inputLength, blockSize) {
+  const remainder = inputLength % blockSize;
+  return remainder === 0 ? blockSize : blockSize - remainder;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CryptoError,
+  DuplicateComponentError,
+  MissingComponentError,
+  assertBlockMultiple,
+  assertBlockSize,
+  assertBytes,
+  assertIv,
+  assertPaddedInput,
+  concatBytes,
+  createRegistry,
+  equalBytes,
+  getBlockPaddingLength,
+  xorBytes
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts", "../src/errors.ts", "../src/bytes.ts", "../src/passphrase.ts", "../src/transform.ts", "../src/registry.ts", "../src/blocks.ts"],
+  "sourcesContent": ["export type {\n  AnyComponent,\n  BlockCipher,\n  BlockCipherComponent,\n  BlockModeTransformParams,\n  CipherComponent,\n  Component,\n  ComponentKind,\n  FormatComponent,\n  FormatParseResult,\n  FormatStringifyParams,\n  KdfComponent,\n  ModeComponent,\n  PaddingComponent,\n  PresetComponent,\n  StreamCipherComponent,\n  StreamCipherTransformParams,\n  Transform,\n} from './component.js';\nexport { CryptoError, DuplicateComponentError, MissingComponentError } from './errors.js';\nexport type {\n  CreatePassphraseCipherOptions,\n  FormatOptions,\n  KdfOptions,\n  PassphraseCipherFacade,\n} from './passphrase.js';\nexport type { CipherFacade, Registry } from './registry.js';\nexport { createRegistry } from './registry.js';\nexport type { CreateTransformOptions } from './transform.js';\nexport { assertBlockMultiple, assertBlockSize, assertIv, assertPaddedInput, getBlockPaddingLength } from './blocks.js';\nexport { assertBytes, concatBytes, equalBytes, xorBytes } from './bytes.js';\n", "export class CryptoError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = new.target.name;\n  }\n}\n\nexport class DuplicateComponentError extends CryptoError {\n  constructor(kind: string, name: string) {\n    super(`Component already registered: ${kind}:${name}`);\n  }\n}\n\nexport class MissingComponentError extends CryptoError {\n  constructor(kind: string, name: string) {\n    super(`Component not found: ${kind}:${name}`);\n  }\n}\n\n", "export function concatBytes(...chunks: readonly Uint8Array[]): Uint8Array {\n  const length = chunks.reduce((sum, chunk) => sum + chunk.length, 0);\n  const output = new Uint8Array(length);\n  let offset = 0;\n\n  for (const chunk of chunks) {\n    output.set(chunk, offset);\n    offset += chunk.length;\n  }\n\n  return output;\n}\n\nexport function equalBytes(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) {\n    return false;\n  }\n\n  let diff = 0;\n  for (let i = 0; i < a.length; i++) {\n    diff |= a[i] ^ b[i];\n  }\n  return diff === 0;\n}\n\nexport function xorBytes(a: Uint8Array, b: Uint8Array): Uint8Array {\n  if (a.length !== b.length) {\n    throw new Error('XOR inputs must have the same length.');\n  }\n\n  const output = new Uint8Array(a.length);\n  for (let i = 0; i < a.length; i++) {\n    output[i] = a[i] ^ b[i];\n  }\n  return output;\n}\n\nexport function assertBytes(value: unknown, name: string): asserts value is Uint8Array {\n  if (!(value instanceof Uint8Array)) {\n    throw new TypeError(`${name} must be a Uint8Array.`);\n  }\n}\n", "import type { CipherComponent, FormatComponent, KdfComponent, Transform } from './component.js';\nimport type { Registry } from './registry.js';\nimport type { CreateTransformOptions } from './transform.js';\nimport { concatBytes } from './bytes.js';\n\nexport interface CreatePassphraseCipherOptions {\n  cipher: string;\n  mode?: string;\n  padding?: string;\n  passphrase: Uint8Array | string;\n  kdf: string | KdfOptions;\n  format?: string | FormatOptions;\n  salt?: Uint8Array;\n  saltSize?: number;\n  keySize?: number;\n  ivSize?: number;\n  [option: string]: unknown;\n}\n\nexport interface KdfOptions {\n  name: string;\n  [option: string]: unknown;\n}\n\nexport interface FormatOptions {\n  name: string;\n  [option: string]: unknown;\n}\n\nexport interface PassphraseCipherFacade {\n  encrypt(plaintext: Uint8Array): Uint8Array;\n  decrypt(input: Uint8Array): Uint8Array;\n  createEncryptor(): Transform;\n  createDecryptor(): Transform;\n}\n\nexport function createPassphraseCipher(\n  registry: Registry,\n  options: CreatePassphraseCipherOptions,\n): PassphraseCipherFacade {\n  return {\n    encrypt(plaintext) {\n      return concatBytes(this.createEncryptor().finalize(plaintext));\n    },\n\n    decrypt(input) {\n      return concatBytes(this.createDecryptor().finalize(input));\n    },\n\n    createEncryptor() {\n      return createPassphraseEncryptor(registry, options);\n    },\n\n    createDecryptor() {\n      return createPassphraseDecryptor(registry, options);\n    },\n  };\n}\n\nfunction createPassphraseEncryptor(\n  registry: Registry,\n  options: CreatePassphraseCipherOptions,\n): Transform {\n  const format = resolveFormat(registry, options);\n  const salt = options.salt ? options.salt.slice() : randomBytes(options.saltSize ?? 8);\n  const { key, iv } = deriveKeyIv(registry, options, salt);\n  const encryptor = registry.createCipher(toTransformOptions(options, key, iv)).createEncryptor();\n\n  if (!format) {\n    return encryptor;\n  }\n\n  if (!isStreamingOpenSslFormat(format)) {\n    return createBufferedFormatEncryptor(format, salt, encryptor);\n  }\n\n  let emittedHeader = false;\n  const emitHeader = (): Uint8Array => {\n    if (emittedHeader) {\n      return new Uint8Array();\n    }\n    emittedHeader = true;\n    return format.stringify({ ciphertext: new Uint8Array(), salt });\n  };\n\n  return {\n    process(input) {\n      return concatBytes(emitHeader(), encryptor.process(input));\n    },\n\n    finalize(input = new Uint8Array()) {\n      return concatBytes(emitHeader(), encryptor.finalize(input));\n    },\n  };\n}\n\nfunction createPassphraseDecryptor(\n  registry: Registry,\n  options: CreatePassphraseCipherOptions,\n): Transform {\n  const format = resolveFormat(registry, options);\n\n  if (!format) {\n    const { key, iv } = deriveKeyIv(registry, options, new Uint8Array());\n    return registry.createCipher(toTransformOptions(options, key, iv)).createDecryptor();\n  }\n\n  if (!isStreamingOpenSslFormat(format)) {\n    return createBufferedFormatDecryptor(registry, options, format);\n  }\n\n  let header = new Uint8Array();\n  let decryptor: Transform | undefined;\n\n  const initDecryptor = (input: Uint8Array): Uint8Array => {\n    if (decryptor) {\n      return input;\n    }\n\n    header = new Uint8Array(concatBytes(header, input));\n    if (header.length < 16) {\n      return new Uint8Array();\n    }\n\n    const parsed = format.parse(header.slice(0, 16));\n    const hasSalt = parsed.salt !== undefined;\n    const salt = parsed.salt ?? new Uint8Array();\n    const ciphertext = hasSalt ? concatBytes(parsed.ciphertext, header.slice(16)) : header;\n    const { key, iv } = deriveKeyIv(registry, options, salt);\n    decryptor = registry.createCipher(toTransformOptions(options, key, iv)).createDecryptor();\n    header = new Uint8Array();\n    return ciphertext;\n  };\n\n  return {\n    process(input) {\n      const ciphertext = initDecryptor(input);\n      return decryptor ? decryptor.process(ciphertext) : new Uint8Array();\n    },\n\n    finalize(input = new Uint8Array()) {\n      const ciphertext = initDecryptor(input);\n      if (!decryptor) {\n        const { key, iv } = deriveKeyIv(registry, options, new Uint8Array());\n        decryptor = registry.createCipher(toTransformOptions(options, key, iv)).createDecryptor();\n        const buffered = header;\n        header = new Uint8Array();\n        return decryptor.finalize(buffered);\n      }\n      return decryptor.finalize(ciphertext);\n    },\n  };\n}\n\nfunction createBufferedFormatEncryptor(\n  format: FormatComponent,\n  salt: Uint8Array,\n  encryptor: Transform,\n): Transform {\n  const chunks: Uint8Array[] = [];\n\n  return {\n    process(input) {\n      const output = encryptor.process(input);\n      if (output.length !== 0) {\n        chunks.push(output);\n      }\n      return new Uint8Array();\n    },\n\n    finalize(input = new Uint8Array()) {\n      const output = encryptor.finalize(input);\n      if (output.length !== 0) {\n        chunks.push(output);\n      }\n      return format.stringify({ ciphertext: concatBytes(...chunks), salt });\n    },\n  };\n}\n\nfunction createBufferedFormatDecryptor(\n  registry: Registry,\n  options: CreatePassphraseCipherOptions,\n  format: FormatComponent,\n): Transform {\n  const chunks: Uint8Array[] = [];\n\n  return {\n    process(input) {\n      if (input.length !== 0) {\n        chunks.push(input);\n      }\n      return new Uint8Array();\n    },\n\n    finalize(input = new Uint8Array()) {\n      if (input.length !== 0) {\n        chunks.push(input);\n      }\n      const parsed = format.parse(concatBytes(...chunks));\n      const { key, iv } = deriveKeyIv(registry, options, parsed.salt ?? new Uint8Array());\n      return registry.createCipher(toTransformOptions(options, key, iv)).decrypt(parsed.ciphertext);\n    },\n  };\n}\n\nfunction deriveKeyIv(\n  registry: Registry,\n  options: CreatePassphraseCipherOptions,\n  salt: Uint8Array,\n): { key: Uint8Array; iv?: Uint8Array } {\n  const keySize = resolveKeySize(registry, options);\n  const ivSize = resolveIvSize(registry, options);\n  const derived = deriveSync(registry, options, salt, keySize + ivSize);\n  return {\n    key: derived.slice(0, keySize),\n    iv: ivSize === 0 ? undefined : derived.slice(keySize, keySize + ivSize),\n  };\n}\n\nfunction deriveSync(\n  registry: Registry,\n  options: CreatePassphraseCipherOptions,\n  salt: Uint8Array,\n  length: number,\n): Uint8Array {\n  const kdfOptions = normalizeNamedOptions(options.kdf);\n  const kdf = registry.get<'kdf', KdfComponent>('kdf', kdfOptions.name);\n  const result = kdf.derive({\n    ...withoutName(kdfOptions),\n    passphrase: options.passphrase,\n    salt,\n    length,\n  });\n  if (result instanceof Promise) {\n    throw new Error(`KDF ${kdfOptions.name} is asynchronous; use an async passphrase cipher API.`);\n  }\n  return result;\n}\n\nfunction toTransformOptions(\n  options: CreatePassphraseCipherOptions,\n  key: Uint8Array,\n  iv: Uint8Array | undefined,\n): CreateTransformOptions {\n  const {\n    passphrase,\n    kdf,\n    format,\n    salt,\n    saltSize,\n    keySize,\n    ivSize,\n    ...transformOptions\n  } = options;\n\n  return {\n    ...transformOptions,\n    key,\n    ...(iv ? { iv } : {}),\n  };\n}\n\nfunction resolveKeySize(registry: Registry, options: CreatePassphraseCipherOptions): number {\n  if (options.keySize !== undefined) {\n    assertPositiveInteger(options.keySize, 'keySize');\n    return options.keySize;\n  }\n\n  const cipher = registry.get<'cipher', CipherComponent>('cipher', options.cipher);\n  if (!cipher.keySizes || cipher.keySizes.length === 0) {\n    throw new Error(`${options.cipher} passphrase cipher requires keySize.`);\n  }\n  return Math.max(...cipher.keySizes);\n}\n\nfunction resolveIvSize(registry: Registry, options: CreatePassphraseCipherOptions): number {\n  if (options.ivSize !== undefined) {\n    assertNonNegativeInteger(options.ivSize, 'ivSize');\n    return options.ivSize;\n  }\n\n  const cipher = registry.get<'cipher', CipherComponent>('cipher', options.cipher);\n  return cipher.type === 'block' ? cipher.blockSize : 0;\n}\n\nfunction resolveFormat(\n  registry: Registry,\n  options: CreatePassphraseCipherOptions,\n): FormatComponent | undefined {\n  if (!options.format) {\n    return undefined;\n  }\n  return registry.get<'format', FormatComponent>('format', normalizeNamedOptions(options.format).name);\n}\n\nfunction isStreamingOpenSslFormat(format: FormatComponent): boolean {\n  return format.name === 'OpenSSL';\n}\n\nfunction normalizeNamedOptions(options: string | { name: string }): { name: string; [option: string]: unknown } {\n  return typeof options === 'string' ? { name: options } : options;\n}\n\nfunction withoutName(options: { name: string; [option: string]: unknown }): Record<string, unknown> {\n  const { name, ...rest } = options;\n  return rest;\n}\n\nfunction randomBytes(length: number): Uint8Array {\n  assertNonNegativeInteger(length, 'saltSize');\n  const bytes = new Uint8Array(length);\n  if (bytes.length === 0) {\n    return bytes;\n  }\n\n  const crypto = globalThis as typeof globalThis & {\n    crypto?: {\n      getRandomValues<T extends Uint8Array>(array: T): T;\n    };\n  };\n  crypto.crypto?.getRandomValues(bytes);\n  if (bytes.some((byte) => byte !== 0)) {\n    return bytes;\n  }\n\n  for (let i = 0; i < bytes.length; i++) {\n    bytes[i] = Math.floor(Math.random() * 256);\n  }\n  return bytes;\n}\n\nfunction assertPositiveInteger(value: number, label: string): void {\n  if (!Number.isInteger(value) || value <= 0) {\n    throw new RangeError(`${label} must be a positive integer.`);\n  }\n}\n\nfunction assertNonNegativeInteger(value: number, label: string): void {\n  if (!Number.isInteger(value) || value < 0) {\n    throw new RangeError(`${label} must be a non-negative integer.`);\n  }\n}\n", "import type { BlockCipherComponent, CipherComponent, ModeComponent, PaddingComponent, Transform } from './component.js';\nimport type { Registry } from './registry.js';\nimport { concatBytes } from './bytes.js';\n\nexport interface CreateTransformOptions {\n  cipher: string;\n  mode?: string;\n  padding?: string;\n  key: Uint8Array;\n  iv?: Uint8Array;\n  [option: string]: unknown;\n}\n\nexport function createEncryptor(registry: Registry, options: CreateTransformOptions): Transform {\n  const cipher = registry.get<'cipher', CipherComponent>('cipher', options.cipher);\n  if (cipher.type === 'stream') {\n    return createStreamEncryptor(cipher.createEncryptor({\n      key: options.key,\n      options,\n    }));\n  }\n\n  const { mode, padding } = resolveBlockOptions(registry, options);\n  const blockCipher = cipher.create(options.key);\n\n  const modeEncryptor = mode.createEncryptor({\n    cipher: blockCipher,\n    iv: options.iv,\n  });\n\n  if (mode.requiresPadding === false) {\n    return createStreamEncryptor(modeEncryptor);\n  }\n\n  let finalized = false;\n  let pending: Uint8Array = new Uint8Array();\n\n  return {\n    process(input) {\n      assertNotFinalized(finalized);\n      const data = concatBytes(pending, input);\n      const processLength = data.length - (data.length % blockCipher.blockSize);\n      pending = data.slice(processLength);\n      return processLength === 0 ? new Uint8Array() : modeEncryptor.process(data.subarray(0, processLength));\n    },\n\n    finalize(input = new Uint8Array()) {\n      assertNotFinalized(finalized);\n      const processed = input.length === 0 ? new Uint8Array() : this.process(input);\n      finalized = true;\n      const finalBlock = padding.pad(pending, blockCipher.blockSize);\n      pending = new Uint8Array();\n      return concatBytes(processed, modeEncryptor.finalize(finalBlock));\n    },\n  };\n}\n\nexport function createDecryptor(registry: Registry, options: CreateTransformOptions): Transform {\n  const cipher = registry.get<'cipher', CipherComponent>('cipher', options.cipher);\n  if (cipher.type === 'stream') {\n    return createStreamDecryptor(cipher.createDecryptor({\n      key: options.key,\n      options,\n    }));\n  }\n\n  const { mode, padding } = resolveBlockOptions(registry, options);\n  const blockCipher = cipher.create(options.key);\n\n  const modeDecryptor = mode.createDecryptor({\n    cipher: blockCipher,\n    iv: options.iv,\n  });\n\n  if (mode.requiresPadding === false) {\n    return createStreamDecryptor(modeDecryptor);\n  }\n\n  let finalized = false;\n  let pending: Uint8Array = new Uint8Array();\n  let plaintextPending: Uint8Array = new Uint8Array();\n\n  return {\n    process(input) {\n      assertNotFinalized(finalized);\n      const data = concatBytes(pending, input);\n      const processLength = data.length - (data.length % blockCipher.blockSize);\n      pending = data.slice(processLength);\n\n      if (processLength === 0) {\n        return new Uint8Array();\n      }\n\n      const decrypted = modeDecryptor.process(data.subarray(0, processLength));\n      const output = plaintextPending;\n      plaintextPending = decrypted;\n      return output;\n    },\n\n    finalize(input = new Uint8Array()) {\n      assertNotFinalized(finalized);\n      const processed = input.length === 0 ? new Uint8Array() : this.process(input);\n      finalized = true;\n      if (pending.length !== 0) {\n        padding.unpad(pending, blockCipher.blockSize);\n      }\n      const finalPlaintext = padding.unpad(plaintextPending, blockCipher.blockSize);\n      pending = new Uint8Array();\n      plaintextPending = new Uint8Array();\n      return concatBytes(processed, finalPlaintext, modeDecryptor.finalize());\n    },\n  };\n}\n\nfunction createStreamEncryptor(modeEncryptor: Transform): Transform {\n  let finalized = false;\n\n  return {\n    process(input) {\n      assertNotFinalized(finalized);\n      return modeEncryptor.process(input);\n    },\n\n    finalize(input = new Uint8Array()) {\n      assertNotFinalized(finalized);\n      finalized = true;\n      return concatBytes(\n        input.length === 0 ? new Uint8Array() : modeEncryptor.process(input),\n        modeEncryptor.finalize(),\n      );\n    },\n  };\n}\n\nfunction createStreamDecryptor(modeDecryptor: Transform): Transform {\n  let finalized = false;\n\n  return {\n    process(input) {\n      assertNotFinalized(finalized);\n      return modeDecryptor.process(input);\n    },\n\n    finalize(input = new Uint8Array()) {\n      assertNotFinalized(finalized);\n      finalized = true;\n      return concatBytes(\n        input.length === 0 ? new Uint8Array() : modeDecryptor.process(input),\n        modeDecryptor.finalize(),\n      );\n    },\n  };\n}\n\nfunction resolveBlockOptions(registry: Registry, options: CreateTransformOptions): {\n  cipher: BlockCipherComponent;\n  mode: ModeComponent;\n  padding: PaddingComponent;\n} {\n  if (!options.mode) {\n    throw new Error(`${options.cipher} block cipher requires a mode.`);\n  }\n  if (!options.padding) {\n    throw new Error(`${options.cipher} block cipher requires padding.`);\n  }\n\n  return {\n    cipher: registry.get<'cipher', BlockCipherComponent>('cipher', options.cipher),\n    mode: registry.get('mode', options.mode),\n    padding: registry.get('padding', options.padding),\n  };\n}\n\nfunction assertNotFinalized(finalized: boolean): void {\n  if (finalized) {\n    throw new Error('Transform is already finalized.');\n  }\n}\n", "import type { AnyComponent, Component, ComponentKind, PresetComponent } from './component.js';\nimport { DuplicateComponentError, MissingComponentError } from './errors.js';\nimport type { CreatePassphraseCipherOptions, PassphraseCipherFacade } from './passphrase.js';\nimport { createPassphraseCipher } from './passphrase.js';\nimport type { CreateTransformOptions } from './transform.js';\nimport { createDecryptor, createEncryptor } from './transform.js';\nimport type { Transform } from './component.js';\n\nexport interface Registry {\n  use(component: AnyComponent): Registry;\n  has(kind: ComponentKind, name: string): boolean;\n  get<Kind extends ComponentKind, T extends Component<Kind>>(kind: Kind, name: string): T;\n  list(kind?: ComponentKind): AnyComponent[];\n  createCipher(options: CreateTransformOptions): CipherFacade;\n  createPassphraseCipher(options: CreatePassphraseCipherOptions): PassphraseCipherFacade;\n  encrypt(options: CreateTransformOptions & { plaintext: Uint8Array }): Uint8Array;\n  decrypt(options: CreateTransformOptions & { ciphertext: Uint8Array }): Uint8Array;\n  createEncryptor(options: CreateTransformOptions): Transform;\n  createDecryptor(options: CreateTransformOptions): Transform;\n}\n\nexport interface CipherFacade {\n  encrypt(plaintext: Uint8Array): Uint8Array;\n  decrypt(ciphertext: Uint8Array): Uint8Array;\n  createEncryptor(): Transform;\n  createDecryptor(): Transform;\n}\n\nexport function createRegistry(components: Iterable<AnyComponent> = []): Registry {\n  const entries = new Map<string, AnyComponent>();\n\n  const key = (kind: ComponentKind, name: string) => `${kind}:${name}`;\n\n  const registry: Registry = {\n    use(component) {\n      if (component.kind === 'preset') {\n        for (const item of (component as PresetComponent).components()) {\n          registry.use(item);\n        }\n        return registry;\n      }\n\n      const entryKey = key(component.kind, component.name);\n      if (entries.has(entryKey)) {\n        throw new DuplicateComponentError(component.kind, component.name);\n      }\n      entries.set(entryKey, component);\n      return registry;\n    },\n\n    has(kind, name) {\n      return entries.has(key(kind, name));\n    },\n\n    get(kind, name) {\n      const component = entries.get(key(kind, name));\n      if (!component) {\n        throw new MissingComponentError(kind, name);\n      }\n      return component as never;\n    },\n\n    list(kind) {\n      const components = [...entries.values()];\n      return kind ? components.filter((component) => component.kind === kind) : components;\n    },\n\n    createCipher(options) {\n      return {\n        encrypt(plaintext) {\n          return createEncryptor(registry, options).finalize(plaintext);\n        },\n\n        decrypt(ciphertext) {\n          return createDecryptor(registry, options).finalize(ciphertext);\n        },\n\n        createEncryptor() {\n          return createEncryptor(registry, options);\n        },\n\n        createDecryptor() {\n          return createDecryptor(registry, options);\n        },\n      };\n    },\n\n    createPassphraseCipher(options) {\n      return createPassphraseCipher(registry, options);\n    },\n\n    encrypt(options) {\n      return createEncryptor(registry, options).finalize(options.plaintext);\n    },\n\n    decrypt(options) {\n      return createDecryptor(registry, options).finalize(options.ciphertext);\n    },\n\n    createEncryptor(options) {\n      return createEncryptor(registry, options);\n    },\n\n    createDecryptor(options) {\n      return createDecryptor(registry, options);\n    },\n  };\n\n  for (const component of components) {\n    registry.use(component);\n  }\n\n  return registry;\n}\n", "export interface BlockSizeOptions {\n  readonly max?: number;\n}\n\nexport function assertBlockSize(blockSize: number, options: BlockSizeOptions = {}): void {\n  const { max } = options;\n  if (!Number.isInteger(blockSize) || blockSize <= 0) {\n    throw new RangeError('blockSize must be a positive integer.');\n  }\n  if (max !== undefined && blockSize > max) {\n    throw new RangeError(`blockSize must be an integer between 1 and ${max}.`);\n  }\n}\n\nexport function assertBlockMultiple(input: Uint8Array, blockSize: number, label: string): void {\n  assertBlockSize(blockSize);\n  if (input.length % blockSize !== 0) {\n    throw new Error(`${label} input length must be a multiple of the block size.`);\n  }\n}\n\nexport function assertPaddedInput(input: Uint8Array, blockSize: number, label: string, options: BlockSizeOptions = {}): void {\n  assertBlockSize(blockSize, options);\n  if (input.length === 0 || input.length % blockSize !== 0) {\n    throw new Error(`Invalid ${label} padded data.`);\n  }\n}\n\nexport function assertIv(blockSize: number, iv: Uint8Array | undefined, modeName: string): asserts iv is Uint8Array {\n  if (!iv) {\n    throw new Error(`${modeName} mode requires an IV.`);\n  }\n  if (iv.length !== blockSize) {\n    throw new Error(`${modeName} IV length must match the cipher block size.`);\n  }\n}\n\nexport function getBlockPaddingLength(inputLength: number, blockSize: number): number {\n  const remainder = inputLength % blockSize;\n  return remainder === 0 ? blockSize : blockSize - remainder;\n}\n"],
+  "mappings": "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",
+  "names": ["components"]
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export type { AnyComponent, BlockCipher, BlockCipherComponent, BlockModeTransformParams, CipherComponent, Component, ComponentKind, FormatComponent, FormatParseResult, FormatStringifyParams, KdfComponent, ModeComponent, PaddingComponent, PresetComponent, StreamCipherComponent, StreamCipherTransformParams, Transform, } from './component.js';
+export { CryptoError, DuplicateComponentError, MissingComponentError } from './errors.js';
+export type { CreatePassphraseCipherOptions, FormatOptions, KdfOptions, PassphraseCipherFacade, } from './passphrase.js';
+export type { CipherFacade, Registry } from './registry.js';
+export { createRegistry } from './registry.js';
+export type { CreateTransformOptions } from './transform.js';
+export { assertBlockMultiple, assertBlockSize, assertIv, assertPaddedInput, getBlockPaddingLength } from './blocks.js';
+export { assertBytes, concatBytes, equalBytes, xorBytes } from './bytes.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,WAAW,EACX,oBAAoB,EACpB,wBAAwB,EACxB,eAAe,EACf,SAAS,EACT,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,qBAAqB,EACrB,2BAA2B,EAC3B,SAAS,GACV,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAC1F,YAAY,EACV,6BAA6B,EAC7B,aAAa,EACb,UAAU,EACV,sBAAsB,GACvB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,QAAQ,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACvH,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}