zeed 1.2.4 → 1.3.1

package/dist/common/crypto/aes-sealed.cjs

@@ -1,2 +1,35 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkL5IXZXHRcjs = require('../../chunk-L5IXZXHR.cjs');require('../../chunk-TNMEWZPW.cjs');require('../../chunk-5RHVNJKM.cjs');require('../../chunk-P7XCQ7WV.cjs');exports.decryptAesGcm = _chunkL5IXZXHRcjs.b; exports.encryptAesGcm = _chunkL5IXZXHRcjs.a;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_bin = require('../../bin-Ddaz2lxM.cjs');
+
+//#region src/common/crypto/aes-sealed.ts
+const AES_GCM_TAG_LENGTH_BITS = 128;
+async function encryptAesGcm(data, key, authenticating = new Uint8Array()) {
+	const iv = crypto.getRandomValues(new Uint8Array(12));
+	const encrypted = await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv,
+		tagLength: AES_GCM_TAG_LENGTH_BITS,
+		additionalData: require_bin.ensureUint8Array(authenticating)
+	}, key, require_bin.ensureUint8Array(data));
+	const encryptedArray = new Uint8Array(encrypted);
+	const combined = new Uint8Array(iv.length + encryptedArray.length);
+	combined.set(iv);
+	combined.set(encryptedArray, iv.length);
+	return combined;
+}
+async function decryptAesGcm(data, key, authenticating = new Uint8Array()) {
+	const iv = require_bin.ensureUint8Array(data.slice(0, 12));
+	const encrypted = require_bin.ensureUint8Array(data.slice(12));
+	const decrypted = await crypto.subtle.decrypt({
+		name: "AES-GCM",
+		iv,
+		tagLength: AES_GCM_TAG_LENGTH_BITS,
+		additionalData: require_bin.ensureUint8Array(authenticating)
+	}, key, encrypted);
+	return new Uint8Array(decrypted);
+}
+
+//#endregion
+exports.decryptAesGcm = decryptAesGcm;
+exports.encryptAesGcm = encryptAesGcm;
 //# sourceMappingURL=aes-sealed.cjs.map

package/dist/common/crypto/aes-sealed.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/crypto/aes-sealed.cjs"],"names":[],"mappings":"AAAA,qIAAyC,oCAAiC,oCAAiC,oCAAiC,yFAA8C","file":"/Users/dirk/work/github-zeed/dist/common/crypto/aes-sealed.cjs"}
+{"version":3,"file":"aes-sealed.cjs","names":["ensureUint8Array"],"sources":["../../../src/common/crypto/aes-sealed.ts"],"sourcesContent":["import { ensureUint8Array } from '../data/bin'\n\nconst AES_GCM_TAG_LENGTH_BITS = 128\n\nexport async function encryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating: Uint8Array = new Uint8Array()): Promise<Uint8Array> {\n  const iv = crypto.getRandomValues(new Uint8Array(12)) // AES-GCM requires a 12-byte IV\n  const encrypted = await crypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv,\n      tagLength: AES_GCM_TAG_LENGTH_BITS,\n      additionalData: ensureUint8Array(authenticating),\n    },\n    key,\n    ensureUint8Array(data),\n  )\n\n  const encryptedArray = new Uint8Array(encrypted)\n  const combined = new Uint8Array(iv.length + encryptedArray.length)\n  combined.set(iv)\n  combined.set(encryptedArray, iv.length)\n  return combined\n}\n\nexport async function decryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating: Uint8Array = new Uint8Array()): Promise<Uint8Array> {\n  const iv = ensureUint8Array(data.slice(0, 12)) // nonce is the first 12 bytes\n  const encrypted = ensureUint8Array(data.slice(12)) // ciphertext and tag of 128 bits\n  const decrypted = await crypto.subtle.decrypt({\n    name: 'AES-GCM',\n    iv,\n    tagLength: AES_GCM_TAG_LENGTH_BITS,\n    additionalData: ensureUint8Array(authenticating),\n  }, key, encrypted)\n  return new Uint8Array(decrypted)\n}\n"],"mappings":";;;;AAEA,MAAM,0BAA0B;AAEhC,eAAsB,cAAc,MAAkB,KAAgB,iBAA6B,IAAI,YAAY,EAAuB;CACxI,MAAM,KAAK,OAAO,gBAAgB,IAAI,WAAW,GAAG,CAAC;CACrD,MAAM,YAAY,MAAM,OAAO,OAAO,QACpC;EACE,MAAM;EACN;EACA,WAAW;EACX,gBAAgBA,6BAAiB,eAAe;EACjD,EACD,KACAA,6BAAiB,KAAK,CACvB;CAED,MAAM,iBAAiB,IAAI,WAAW,UAAU;CAChD,MAAM,WAAW,IAAI,WAAW,GAAG,SAAS,eAAe,OAAO;AAClE,UAAS,IAAI,GAAG;AAChB,UAAS,IAAI,gBAAgB,GAAG,OAAO;AACvC,QAAO;;AAGT,eAAsB,cAAc,MAAkB,KAAgB,iBAA6B,IAAI,YAAY,EAAuB;CACxI,MAAM,KAAKA,6BAAiB,KAAK,MAAM,GAAG,GAAG,CAAC;CAC9C,MAAM,YAAYA,6BAAiB,KAAK,MAAM,GAAG,CAAC;CAClD,MAAM,YAAY,MAAM,OAAO,OAAO,QAAQ;EAC5C,MAAM;EACN;EACA,WAAW;EACX,gBAAgBA,6BAAiB,eAAe;EACjD,EAAE,KAAK,UAAU;AAClB,QAAO,IAAI,WAAW,UAAU"}

package/dist/common/crypto/aes-sealed.d.cts

@@ -1,4 +1,2 @@
-declare function encryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating?: Uint8Array): Promise<Uint8Array>;
-declare function decryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating?: Uint8Array): Promise<Uint8Array>;
-
-export { decryptAesGcm, encryptAesGcm };
+import { n as encryptAesGcm, t as decryptAesGcm } from "../../aes-sealed-Q4saTGg2.cjs";
+export { decryptAesGcm, encryptAesGcm };

package/dist/common/crypto/aes-sealed.d.mts

@@ -0,0 +1,2 @@
+import { n as encryptAesGcm, t as decryptAesGcm } from "../../aes-sealed-CEgjlCzA.mjs";
+export { decryptAesGcm, encryptAesGcm };

package/dist/common/crypto/aes-sealed.mjs

@@ -0,0 +1,33 @@
+import { o as ensureUint8Array } from "../../bin-BAoS4qtm.mjs";
+
+//#region src/common/crypto/aes-sealed.ts
+const AES_GCM_TAG_LENGTH_BITS = 128;
+async function encryptAesGcm(data, key, authenticating = new Uint8Array()) {
+	const iv = crypto.getRandomValues(new Uint8Array(12));
+	const encrypted = await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv,
+		tagLength: AES_GCM_TAG_LENGTH_BITS,
+		additionalData: ensureUint8Array(authenticating)
+	}, key, ensureUint8Array(data));
+	const encryptedArray = new Uint8Array(encrypted);
+	const combined = new Uint8Array(iv.length + encryptedArray.length);
+	combined.set(iv);
+	combined.set(encryptedArray, iv.length);
+	return combined;
+}
+async function decryptAesGcm(data, key, authenticating = new Uint8Array()) {
+	const iv = ensureUint8Array(data.slice(0, 12));
+	const encrypted = ensureUint8Array(data.slice(12));
+	const decrypted = await crypto.subtle.decrypt({
+		name: "AES-GCM",
+		iv,
+		tagLength: AES_GCM_TAG_LENGTH_BITS,
+		additionalData: ensureUint8Array(authenticating)
+	}, key, encrypted);
+	return new Uint8Array(decrypted);
+}
+
+//#endregion
+export { decryptAesGcm, encryptAesGcm };
+//# sourceMappingURL=aes-sealed.mjs.map

package/dist/common/crypto/aes-sealed.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aes-sealed.mjs","names":[],"sources":["../../../src/common/crypto/aes-sealed.ts"],"sourcesContent":["import { ensureUint8Array } from '../data/bin'\n\nconst AES_GCM_TAG_LENGTH_BITS = 128\n\nexport async function encryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating: Uint8Array = new Uint8Array()): Promise<Uint8Array> {\n  const iv = crypto.getRandomValues(new Uint8Array(12)) // AES-GCM requires a 12-byte IV\n  const encrypted = await crypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv,\n      tagLength: AES_GCM_TAG_LENGTH_BITS,\n      additionalData: ensureUint8Array(authenticating),\n    },\n    key,\n    ensureUint8Array(data),\n  )\n\n  const encryptedArray = new Uint8Array(encrypted)\n  const combined = new Uint8Array(iv.length + encryptedArray.length)\n  combined.set(iv)\n  combined.set(encryptedArray, iv.length)\n  return combined\n}\n\nexport async function decryptAesGcm(data: Uint8Array, key: CryptoKey, authenticating: Uint8Array = new Uint8Array()): Promise<Uint8Array> {\n  const iv = ensureUint8Array(data.slice(0, 12)) // nonce is the first 12 bytes\n  const encrypted = ensureUint8Array(data.slice(12)) // ciphertext and tag of 128 bits\n  const decrypted = await crypto.subtle.decrypt({\n    name: 'AES-GCM',\n    iv,\n    tagLength: AES_GCM_TAG_LENGTH_BITS,\n    additionalData: ensureUint8Array(authenticating),\n  }, key, encrypted)\n  return new Uint8Array(decrypted)\n}\n"],"mappings":";;;AAEA,MAAM,0BAA0B;AAEhC,eAAsB,cAAc,MAAkB,KAAgB,iBAA6B,IAAI,YAAY,EAAuB;CACxI,MAAM,KAAK,OAAO,gBAAgB,IAAI,WAAW,GAAG,CAAC;CACrD,MAAM,YAAY,MAAM,OAAO,OAAO,QACpC;EACE,MAAM;EACN;EACA,WAAW;EACX,gBAAgB,iBAAiB,eAAe;EACjD,EACD,KACA,iBAAiB,KAAK,CACvB;CAED,MAAM,iBAAiB,IAAI,WAAW,UAAU;CAChD,MAAM,WAAW,IAAI,WAAW,GAAG,SAAS,eAAe,OAAO;AAClE,UAAS,IAAI,GAAG;AAChB,UAAS,IAAI,gBAAgB,GAAG,OAAO;AACvC,QAAO;;AAGT,eAAsB,cAAc,MAAkB,KAAgB,iBAA6B,IAAI,YAAY,EAAuB;CACxI,MAAM,KAAK,iBAAiB,KAAK,MAAM,GAAG,GAAG,CAAC;CAC9C,MAAM,YAAY,iBAAiB,KAAK,MAAM,GAAG,CAAC;CAClD,MAAM,YAAY,MAAM,OAAO,OAAO,QAAQ;EAC5C,MAAM;EACN;EACA,WAAW;EACX,gBAAgB,iBAAiB,eAAe;EACjD,EAAE,KAAK,UAAU;AAClB,QAAO,IAAI,WAAW,UAAU"}

package/dist/common/crypto/crypto.cjs

@@ -1,2 +1,92 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkLUPESR7Scjs = require('../../chunk-LUPESR7S.cjs');require('../../chunk-TNMEWZPW.cjs');require('../../chunk-5RHVNJKM.cjs');require('../../chunk-P7XCQ7WV.cjs');exports.CRYPTO_DEFAULT_ALG = _chunkLUPESR7Scjs.c; exports.CRYPTO_DEFAULT_DERIVE_ALG = _chunkLUPESR7Scjs.d; exports.CRYPTO_DEFAULT_DERIVE_ITERATIONS = _chunkLUPESR7Scjs.e; exports.CRYPTO_DEFAULT_HASH_ALG = _chunkLUPESR7Scjs.b; exports.CRYPTO_DEFAULT_IV_LENGTH = _chunkLUPESR7Scjs.f; exports.decrypt = _chunkLUPESR7Scjs.k; exports.deriveKeyPbkdf2 = _chunkLUPESR7Scjs.h; exports.deriveKeyPbkdf2CBC = _chunkLUPESR7Scjs.i; exports.digest = _chunkLUPESR7Scjs.g; exports.encrypt = _chunkLUPESR7Scjs.j; exports.randomUint8Array = _chunkLUPESR7Scjs.a;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_bin = require('../../bin-Ddaz2lxM.cjs');
+
+//#region src/common/crypto/crypto.ts
+/** Get random bytes using window.crypto if available. Else use a poor fallback solution. */
+function randomUint8Array(length = 16) {
+	const randomBytes = new Uint8Array(length);
+	if (typeof crypto !== "undefined" && crypto.getRandomValues) crypto.getRandomValues(randomBytes);
+	else for (let i = 0; i < length; i++) randomBytes[i] = Math.floor(Math.random() * 256);
+	return randomBytes;
+}
+const CRYPTO_DEFAULT_HASH_ALG = "SHA-256";
+const CRYPTO_DEFAULT_ALG = "AES-GCM";
+const CRYPTO_DEFAULT_DERIVE_ALG = "PBKDF2";
+const CRYPTO_DEFAULT_DERIVE_ITERATIONS = 1e5;
+const CRYPTO_DEFAULT_IV_LENGTH = 12;
+async function digest(message, algorithm = CRYPTO_DEFAULT_HASH_ALG) {
+	const m = require_bin.ensureUint8Array(require_bin.toUint8Array(message));
+	return require_bin.toUint8Array(await crypto.subtle.digest(algorithm, m));
+}
+async function deriveKeyPbkdf2(secret, opt = {}) {
+	const secretBuffer = require_bin.ensureUint8Array(require_bin.toUint8Array(secret));
+	const keyMaterial = await crypto.subtle.importKey("raw", secretBuffer, CRYPTO_DEFAULT_DERIVE_ALG, false, ["deriveKey"]);
+	return await crypto.subtle.deriveKey({
+		name: CRYPTO_DEFAULT_DERIVE_ALG,
+		salt: opt.salt ? require_bin.ensureUint8Array(require_bin.toUint8Array(opt.salt)) : new Uint8Array(0),
+		iterations: opt.iterations ?? 1e5,
+		hash: CRYPTO_DEFAULT_HASH_ALG
+	}, keyMaterial, {
+		name: CRYPTO_DEFAULT_ALG,
+		length: 256
+	}, true, ["encrypt", "decrypt"]);
+}
+async function deriveKeyPbkdf2CBC(secret, opt = {}) {
+	const secretBuffer = require_bin.ensureUint8Array(require_bin.toUint8Array(secret));
+	const keyMaterial = await crypto.subtle.importKey("raw", secretBuffer, CRYPTO_DEFAULT_DERIVE_ALG, false, ["deriveKey"]);
+	return await crypto.subtle.deriveKey({
+		name: CRYPTO_DEFAULT_DERIVE_ALG,
+		salt: opt.salt ? require_bin.ensureUint8Array(require_bin.toUint8Array(opt.salt)) : new Uint8Array(0),
+		iterations: opt.iterations ?? 1e5,
+		hash: CRYPTO_DEFAULT_HASH_ALG
+	}, keyMaterial, {
+		name: "AES-CBC",
+		length: 256
+	}, true, ["encrypt", "decrypt"]);
+}
+function getMagicId() {
+	return new Uint8Array([1, 1]);
+}
+async function encrypt(data, key) {
+	const MAGIC_ID = getMagicId();
+	const iv = randomUint8Array(12);
+	const cipher = await crypto.subtle.encrypt({
+		name: CRYPTO_DEFAULT_ALG,
+		iv: require_bin.ensureUint8Array(iv)
+	}, key, require_bin.ensureUint8Array(data));
+	const binCypher = new Uint8Array(cipher);
+	const bufferLength = MAGIC_ID.length + iv.length + binCypher.length;
+	const buffer = new Uint8Array(bufferLength);
+	let pos = 0;
+	buffer.set(MAGIC_ID, pos);
+	pos += MAGIC_ID.length;
+	buffer.set(iv, pos);
+	pos += iv.length;
+	buffer.set(binCypher, pos);
+	return buffer;
+}
+async function decrypt(data, key) {
+	const magic = require_bin.ensureUint8Array(data.subarray(0, 2));
+	if (!require_bin.equalBinary(magic, getMagicId())) return Promise.reject(/* @__PURE__ */ new Error(`Unknown magic ${magic}`));
+	const iv = require_bin.ensureUint8Array(data.subarray(2, 2 + 12));
+	const cipher = require_bin.ensureUint8Array(data.subarray(2 + 12, data.length));
+	const plain = await crypto.subtle.decrypt({
+		name: CRYPTO_DEFAULT_ALG,
+		iv
+	}, key, cipher);
+	return new Uint8Array(plain);
+}
+
+//#endregion
+exports.CRYPTO_DEFAULT_ALG = CRYPTO_DEFAULT_ALG;
+exports.CRYPTO_DEFAULT_DERIVE_ALG = CRYPTO_DEFAULT_DERIVE_ALG;
+exports.CRYPTO_DEFAULT_DERIVE_ITERATIONS = CRYPTO_DEFAULT_DERIVE_ITERATIONS;
+exports.CRYPTO_DEFAULT_HASH_ALG = CRYPTO_DEFAULT_HASH_ALG;
+exports.CRYPTO_DEFAULT_IV_LENGTH = CRYPTO_DEFAULT_IV_LENGTH;
+exports.decrypt = decrypt;
+exports.deriveKeyPbkdf2 = deriveKeyPbkdf2;
+exports.deriveKeyPbkdf2CBC = deriveKeyPbkdf2CBC;
+exports.digest = digest;
+exports.encrypt = encrypt;
+exports.randomUint8Array = randomUint8Array;
 //# sourceMappingURL=crypto.cjs.map

package/dist/common/crypto/crypto.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/crypto/crypto.cjs"],"names":[],"mappings":"AAAA,qIAA2D,oCAAiC,oCAAiC,oCAAiC,8hBAAyQ","file":"/Users/dirk/work/github-zeed/dist/common/crypto/crypto.cjs"}
+{"version":3,"file":"crypto.cjs","names":["ensureUint8Array","toUint8Array","equalBinary"],"sources":["../../../src/common/crypto/crypto.ts"],"sourcesContent":["import type { BinInput } from '../data/bin-types'\nimport { ensureUint8Array, equalBinary, toUint8Array } from '../data/bin'\n\n/** Get random bytes using window.crypto if available. Else use a poor fallback solution. */\nexport function randomUint8Array(length = 16): Uint8Array {\n  const randomBytes = new Uint8Array(length)\n  if (typeof crypto !== 'undefined' && crypto.getRandomValues) {\n    crypto.getRandomValues(randomBytes)\n  }\n  else {\n    // hack: not state of the art secure\n    // throw \"crypto.getRandomValues is required\"\n    for (let i = 0; i < length; i++) {\n      // Math.random: \"...range 0 to less than 1 (inclusive of 0, but not 1)\"\n      // 0.9... * 0xff < 255 therefore * 0x100\n      randomBytes[i] = Math.floor(Math.random() * 0x100) // 0...255\n    }\n  }\n  return randomBytes\n}\n\nexport const CRYPTO_DEFAULT_HASH_ALG = 'SHA-256'\nexport const CRYPTO_DEFAULT_ALG = 'AES-GCM'\nexport const CRYPTO_DEFAULT_DERIVE_ALG = 'PBKDF2'\nexport const CRYPTO_DEFAULT_DERIVE_ITERATIONS = 100000\nexport const CRYPTO_DEFAULT_IV_LENGTH = 12\n\nexport async function digest(\n  message: BinInput,\n  algorithm: AlgorithmIdentifier = CRYPTO_DEFAULT_HASH_ALG,\n): Promise<Uint8Array> {\n  const m = ensureUint8Array(toUint8Array(message))\n  return toUint8Array(\n    await crypto.subtle.digest(algorithm, m),\n  )\n}\n\nexport async function deriveKeyPbkdf2(\n  secret: BinInput,\n  opt: {\n    iterations?: number\n    salt?: BinInput\n  } = {},\n): Promise<CryptoKey> {\n  const secretBuffer = ensureUint8Array(toUint8Array(secret))\n  const keyMaterial = await crypto.subtle.importKey(\n    'raw',\n    secretBuffer,\n    CRYPTO_DEFAULT_DERIVE_ALG,\n    false,\n    ['deriveKey'],\n  )\n  return await crypto.subtle.deriveKey(\n    {\n      name: CRYPTO_DEFAULT_DERIVE_ALG,\n      salt: opt.salt ? ensureUint8Array(toUint8Array(opt.salt)) : new Uint8Array(0),\n      iterations: opt.iterations ?? CRYPTO_DEFAULT_DERIVE_ITERATIONS,\n      hash: CRYPTO_DEFAULT_HASH_ALG,\n    },\n    keyMaterial,\n    {\n      name: CRYPTO_DEFAULT_ALG,\n      length: 256,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  )\n}\n\nexport async function deriveKeyPbkdf2CBC(\n  secret: BinInput,\n  opt: {\n    iterations?: number\n    salt?: BinInput\n  } = {},\n): Promise<CryptoKey> {\n  const secretBuffer = ensureUint8Array(toUint8Array(secret))\n  const keyMaterial = await crypto.subtle.importKey(\n    'raw',\n    secretBuffer,\n    CRYPTO_DEFAULT_DERIVE_ALG,\n    false,\n    ['deriveKey'],\n  )\n  return await crypto.subtle.deriveKey(\n    {\n      name: CRYPTO_DEFAULT_DERIVE_ALG,\n      salt: opt.salt ? ensureUint8Array(toUint8Array(opt.salt)) : new Uint8Array(0),\n      iterations: opt.iterations ?? CRYPTO_DEFAULT_DERIVE_ITERATIONS,\n      hash: CRYPTO_DEFAULT_HASH_ALG,\n    },\n    keyMaterial,\n    {\n      name: 'AES-CBC',\n      length: 256,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  )\n}\n\nfunction getMagicId() {\n  return new Uint8Array([1, 1])\n}\n\nexport async function encrypt(\n  data: Uint8Array,\n  key: CryptoKey,\n): Promise<Uint8Array> {\n  const MAGIC_ID = getMagicId()\n  const iv = randomUint8Array(CRYPTO_DEFAULT_IV_LENGTH)\n  const cipher = await crypto.subtle.encrypt(\n    { name: CRYPTO_DEFAULT_ALG, iv: ensureUint8Array(iv) },\n    key,\n    ensureUint8Array(data),\n  )\n  const binCypher = new Uint8Array(cipher)\n  const bufferLength = MAGIC_ID.length + iv.length + binCypher.length\n  const buffer = new Uint8Array(bufferLength)\n  let pos = 0\n  buffer.set(MAGIC_ID, pos)\n  pos += MAGIC_ID.length\n  buffer.set(iv, pos)\n  pos += iv.length\n  buffer.set(binCypher, pos)\n  return buffer\n}\n\nexport async function decrypt(\n  data: Uint8Array,\n  key: CryptoKey,\n): Promise<Uint8Array> {\n  const magic = ensureUint8Array(data.subarray(0, 2))\n  if (!equalBinary(magic, getMagicId()))\n    return Promise.reject(new Error(`Unknown magic ${magic}`))\n\n  const iv = ensureUint8Array(data.subarray(2, 2 + CRYPTO_DEFAULT_IV_LENGTH))\n  const cipher = ensureUint8Array(data.subarray(2 + CRYPTO_DEFAULT_IV_LENGTH, data.length))\n  const plain = await crypto.subtle.decrypt(\n    { name: CRYPTO_DEFAULT_ALG, iv },\n    key,\n    cipher,\n  )\n  return new Uint8Array(plain)\n}\n"],"mappings":";;;;;AAIA,SAAgB,iBAAiB,SAAS,IAAgB;CACxD,MAAM,cAAc,IAAI,WAAW,OAAO;AAC1C,KAAI,OAAO,WAAW,eAAe,OAAO,gBAC1C,QAAO,gBAAgB,YAAY;KAKnC,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,IAG1B,aAAY,KAAK,KAAK,MAAM,KAAK,QAAQ,GAAG,IAAM;AAGtD,QAAO;;AAGT,MAAa,0BAA0B;AACvC,MAAa,qBAAqB;AAClC,MAAa,4BAA4B;AACzC,MAAa,mCAAmC;AAChD,MAAa,2BAA2B;AAExC,eAAsB,OACpB,SACA,YAAiC,yBACZ;CACrB,MAAM,IAAIA,6BAAiBC,yBAAa,QAAQ,CAAC;AACjD,QAAOA,yBACL,MAAM,OAAO,OAAO,OAAO,WAAW,EAAE,CACzC;;AAGH,eAAsB,gBACpB,QACA,MAGI,EAAE,EACc;CACpB,MAAM,eAAeD,6BAAiBC,yBAAa,OAAO,CAAC;CAC3D,MAAM,cAAc,MAAM,OAAO,OAAO,UACtC,OACA,cACA,2BACA,OACA,CAAC,YAAY,CACd;AACD,QAAO,MAAM,OAAO,OAAO,UACzB;EACE,MAAM;EACN,MAAM,IAAI,OAAOD,6BAAiBC,yBAAa,IAAI,KAAK,CAAC,GAAG,IAAI,WAAW,EAAE;EAC7E,YAAY,IAAI;EAChB,MAAM;EACP,EACD,aACA;EACE,MAAM;EACN,QAAQ;EACT,EACD,MACA,CAAC,WAAW,UAAU,CACvB;;AAGH,eAAsB,mBACpB,QACA,MAGI,EAAE,EACc;CACpB,MAAM,eAAeD,6BAAiBC,yBAAa,OAAO,CAAC;CAC3D,MAAM,cAAc,MAAM,OAAO,OAAO,UACtC,OACA,cACA,2BACA,OACA,CAAC,YAAY,CACd;AACD,QAAO,MAAM,OAAO,OAAO,UACzB;EACE,MAAM;EACN,MAAM,IAAI,OAAOD,6BAAiBC,yBAAa,IAAI,KAAK,CAAC,GAAG,IAAI,WAAW,EAAE;EAC7E,YAAY,IAAI;EAChB,MAAM;EACP,EACD,aACA;EACE,MAAM;EACN,QAAQ;EACT,EACD,MACA,CAAC,WAAW,UAAU,CACvB;;AAGH,SAAS,aAAa;AACpB,QAAO,IAAI,WAAW,CAAC,GAAG,EAAE,CAAC;;AAG/B,eAAsB,QACpB,MACA,KACqB;CACrB,MAAM,WAAW,YAAY;CAC7B,MAAM,KAAK,oBAA0C;CACrD,MAAM,SAAS,MAAM,OAAO,OAAO,QACjC;EAAE,MAAM;EAAoB,IAAID,6BAAiB,GAAG;EAAE,EACtD,KACAA,6BAAiB,KAAK,CACvB;CACD,MAAM,YAAY,IAAI,WAAW,OAAO;CACxC,MAAM,eAAe,SAAS,SAAS,GAAG,SAAS,UAAU;CAC7D,MAAM,SAAS,IAAI,WAAW,aAAa;CAC3C,IAAI,MAAM;AACV,QAAO,IAAI,UAAU,IAAI;AACzB,QAAO,SAAS;AAChB,QAAO,IAAI,IAAI,IAAI;AACnB,QAAO,GAAG;AACV,QAAO,IAAI,WAAW,IAAI;AAC1B,QAAO;;AAGT,eAAsB,QACpB,MACA,KACqB;CACrB,MAAM,QAAQA,6BAAiB,KAAK,SAAS,GAAG,EAAE,CAAC;AACnD,KAAI,CAACE,wBAAY,OAAO,YAAY,CAAC,CACnC,QAAO,QAAQ,uBAAO,IAAI,MAAM,iBAAiB,QAAQ,CAAC;CAE5D,MAAM,KAAKF,6BAAiB,KAAK,SAAS,GAAG,OAA6B,CAAC;CAC3E,MAAM,SAASA,6BAAiB,KAAK,SAAS,QAA8B,KAAK,OAAO,CAAC;CACzF,MAAM,QAAQ,MAAM,OAAO,OAAO,QAChC;EAAE,MAAM;EAAoB;EAAI,EAChC,KACA,OACD;AACD,QAAO,IAAI,WAAW,MAAM"}

package/dist/common/crypto/crypto.d.cts

@@ -1,22 +1,2 @@
-import { BinInput } from '../data/bin-types.cjs';
-
-/** Get random bytes using window.crypto if available. Else use a poor fallback solution. */
-declare function randomUint8Array(length?: number): Uint8Array;
-declare const CRYPTO_DEFAULT_HASH_ALG = "SHA-256";
-declare const CRYPTO_DEFAULT_ALG = "AES-GCM";
-declare const CRYPTO_DEFAULT_DERIVE_ALG = "PBKDF2";
-declare const CRYPTO_DEFAULT_DERIVE_ITERATIONS = 100000;
-declare const CRYPTO_DEFAULT_IV_LENGTH = 12;
-declare function digest(message: BinInput, algorithm?: AlgorithmIdentifier): Promise<Uint8Array>;
-declare function deriveKeyPbkdf2(secret: BinInput, opt?: {
-    iterations?: number;
-    salt?: BinInput;
-}): Promise<CryptoKey>;
-declare function deriveKeyPbkdf2CBC(secret: BinInput, opt?: {
-    iterations?: number;
-    salt?: BinInput;
-}): Promise<CryptoKey>;
-declare function encrypt(data: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
-declare function decrypt(data: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
-
-export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, randomUint8Array };
+import { a as CRYPTO_DEFAULT_IV_LENGTH, c as deriveKeyPbkdf2CBC, d as randomUint8Array, i as CRYPTO_DEFAULT_HASH_ALG, l as digest, n as CRYPTO_DEFAULT_DERIVE_ALG, o as decrypt, r as CRYPTO_DEFAULT_DERIVE_ITERATIONS, s as deriveKeyPbkdf2, t as CRYPTO_DEFAULT_ALG, u as encrypt } from "../../crypto-C8VaLy62.cjs";
+export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, randomUint8Array };

package/dist/common/crypto/crypto.d.mts

@@ -0,0 +1,2 @@
+import { a as CRYPTO_DEFAULT_IV_LENGTH, c as deriveKeyPbkdf2CBC, d as randomUint8Array, i as CRYPTO_DEFAULT_HASH_ALG, l as digest, n as CRYPTO_DEFAULT_DERIVE_ALG, o as decrypt, r as CRYPTO_DEFAULT_DERIVE_ITERATIONS, s as deriveKeyPbkdf2, t as CRYPTO_DEFAULT_ALG, u as encrypt } from "../../crypto-D4uSzFEL.mjs";
+export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, randomUint8Array };

package/dist/common/crypto/crypto.mjs

@@ -0,0 +1,81 @@
+import { o as ensureUint8Array, s as equalBinary, v as toUint8Array } from "../../bin-BAoS4qtm.mjs";
+
+//#region src/common/crypto/crypto.ts
+/** Get random bytes using window.crypto if available. Else use a poor fallback solution. */
+function randomUint8Array(length = 16) {
+	const randomBytes = new Uint8Array(length);
+	if (typeof crypto !== "undefined" && crypto.getRandomValues) crypto.getRandomValues(randomBytes);
+	else for (let i = 0; i < length; i++) randomBytes[i] = Math.floor(Math.random() * 256);
+	return randomBytes;
+}
+const CRYPTO_DEFAULT_HASH_ALG = "SHA-256";
+const CRYPTO_DEFAULT_ALG = "AES-GCM";
+const CRYPTO_DEFAULT_DERIVE_ALG = "PBKDF2";
+const CRYPTO_DEFAULT_DERIVE_ITERATIONS = 1e5;
+const CRYPTO_DEFAULT_IV_LENGTH = 12;
+async function digest(message, algorithm = CRYPTO_DEFAULT_HASH_ALG) {
+	const m = ensureUint8Array(toUint8Array(message));
+	return toUint8Array(await crypto.subtle.digest(algorithm, m));
+}
+async function deriveKeyPbkdf2(secret, opt = {}) {
+	const secretBuffer = ensureUint8Array(toUint8Array(secret));
+	const keyMaterial = await crypto.subtle.importKey("raw", secretBuffer, CRYPTO_DEFAULT_DERIVE_ALG, false, ["deriveKey"]);
+	return await crypto.subtle.deriveKey({
+		name: CRYPTO_DEFAULT_DERIVE_ALG,
+		salt: opt.salt ? ensureUint8Array(toUint8Array(opt.salt)) : new Uint8Array(0),
+		iterations: opt.iterations ?? 1e5,
+		hash: CRYPTO_DEFAULT_HASH_ALG
+	}, keyMaterial, {
+		name: CRYPTO_DEFAULT_ALG,
+		length: 256
+	}, true, ["encrypt", "decrypt"]);
+}
+async function deriveKeyPbkdf2CBC(secret, opt = {}) {
+	const secretBuffer = ensureUint8Array(toUint8Array(secret));
+	const keyMaterial = await crypto.subtle.importKey("raw", secretBuffer, CRYPTO_DEFAULT_DERIVE_ALG, false, ["deriveKey"]);
+	return await crypto.subtle.deriveKey({
+		name: CRYPTO_DEFAULT_DERIVE_ALG,
+		salt: opt.salt ? ensureUint8Array(toUint8Array(opt.salt)) : new Uint8Array(0),
+		iterations: opt.iterations ?? 1e5,
+		hash: CRYPTO_DEFAULT_HASH_ALG
+	}, keyMaterial, {
+		name: "AES-CBC",
+		length: 256
+	}, true, ["encrypt", "decrypt"]);
+}
+function getMagicId() {
+	return new Uint8Array([1, 1]);
+}
+async function encrypt(data, key) {
+	const MAGIC_ID = getMagicId();
+	const iv = randomUint8Array(12);
+	const cipher = await crypto.subtle.encrypt({
+		name: CRYPTO_DEFAULT_ALG,
+		iv: ensureUint8Array(iv)
+	}, key, ensureUint8Array(data));
+	const binCypher = new Uint8Array(cipher);
+	const bufferLength = MAGIC_ID.length + iv.length + binCypher.length;
+	const buffer = new Uint8Array(bufferLength);
+	let pos = 0;
+	buffer.set(MAGIC_ID, pos);
+	pos += MAGIC_ID.length;
+	buffer.set(iv, pos);
+	pos += iv.length;
+	buffer.set(binCypher, pos);
+	return buffer;
+}
+async function decrypt(data, key) {
+	const magic = ensureUint8Array(data.subarray(0, 2));
+	if (!equalBinary(magic, getMagicId())) return Promise.reject(/* @__PURE__ */ new Error(`Unknown magic ${magic}`));
+	const iv = ensureUint8Array(data.subarray(2, 2 + 12));
+	const cipher = ensureUint8Array(data.subarray(2 + 12, data.length));
+	const plain = await crypto.subtle.decrypt({
+		name: CRYPTO_DEFAULT_ALG,
+		iv
+	}, key, cipher);
+	return new Uint8Array(plain);
+}
+
+//#endregion
+export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, randomUint8Array };
+//# sourceMappingURL=crypto.mjs.map

package/dist/common/crypto/crypto.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.mjs","names":[],"sources":["../../../src/common/crypto/crypto.ts"],"sourcesContent":["import type { BinInput } from '../data/bin-types'\nimport { ensureUint8Array, equalBinary, toUint8Array } from '../data/bin'\n\n/** Get random bytes using window.crypto if available. Else use a poor fallback solution. */\nexport function randomUint8Array(length = 16): Uint8Array {\n  const randomBytes = new Uint8Array(length)\n  if (typeof crypto !== 'undefined' && crypto.getRandomValues) {\n    crypto.getRandomValues(randomBytes)\n  }\n  else {\n    // hack: not state of the art secure\n    // throw \"crypto.getRandomValues is required\"\n    for (let i = 0; i < length; i++) {\n      // Math.random: \"...range 0 to less than 1 (inclusive of 0, but not 1)\"\n      // 0.9... * 0xff < 255 therefore * 0x100\n      randomBytes[i] = Math.floor(Math.random() * 0x100) // 0...255\n    }\n  }\n  return randomBytes\n}\n\nexport const CRYPTO_DEFAULT_HASH_ALG = 'SHA-256'\nexport const CRYPTO_DEFAULT_ALG = 'AES-GCM'\nexport const CRYPTO_DEFAULT_DERIVE_ALG = 'PBKDF2'\nexport const CRYPTO_DEFAULT_DERIVE_ITERATIONS = 100000\nexport const CRYPTO_DEFAULT_IV_LENGTH = 12\n\nexport async function digest(\n  message: BinInput,\n  algorithm: AlgorithmIdentifier = CRYPTO_DEFAULT_HASH_ALG,\n): Promise<Uint8Array> {\n  const m = ensureUint8Array(toUint8Array(message))\n  return toUint8Array(\n    await crypto.subtle.digest(algorithm, m),\n  )\n}\n\nexport async function deriveKeyPbkdf2(\n  secret: BinInput,\n  opt: {\n    iterations?: number\n    salt?: BinInput\n  } = {},\n): Promise<CryptoKey> {\n  const secretBuffer = ensureUint8Array(toUint8Array(secret))\n  const keyMaterial = await crypto.subtle.importKey(\n    'raw',\n    secretBuffer,\n    CRYPTO_DEFAULT_DERIVE_ALG,\n    false,\n    ['deriveKey'],\n  )\n  return await crypto.subtle.deriveKey(\n    {\n      name: CRYPTO_DEFAULT_DERIVE_ALG,\n      salt: opt.salt ? ensureUint8Array(toUint8Array(opt.salt)) : new Uint8Array(0),\n      iterations: opt.iterations ?? CRYPTO_DEFAULT_DERIVE_ITERATIONS,\n      hash: CRYPTO_DEFAULT_HASH_ALG,\n    },\n    keyMaterial,\n    {\n      name: CRYPTO_DEFAULT_ALG,\n      length: 256,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  )\n}\n\nexport async function deriveKeyPbkdf2CBC(\n  secret: BinInput,\n  opt: {\n    iterations?: number\n    salt?: BinInput\n  } = {},\n): Promise<CryptoKey> {\n  const secretBuffer = ensureUint8Array(toUint8Array(secret))\n  const keyMaterial = await crypto.subtle.importKey(\n    'raw',\n    secretBuffer,\n    CRYPTO_DEFAULT_DERIVE_ALG,\n    false,\n    ['deriveKey'],\n  )\n  return await crypto.subtle.deriveKey(\n    {\n      name: CRYPTO_DEFAULT_DERIVE_ALG,\n      salt: opt.salt ? ensureUint8Array(toUint8Array(opt.salt)) : new Uint8Array(0),\n      iterations: opt.iterations ?? CRYPTO_DEFAULT_DERIVE_ITERATIONS,\n      hash: CRYPTO_DEFAULT_HASH_ALG,\n    },\n    keyMaterial,\n    {\n      name: 'AES-CBC',\n      length: 256,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  )\n}\n\nfunction getMagicId() {\n  return new Uint8Array([1, 1])\n}\n\nexport async function encrypt(\n  data: Uint8Array,\n  key: CryptoKey,\n): Promise<Uint8Array> {\n  const MAGIC_ID = getMagicId()\n  const iv = randomUint8Array(CRYPTO_DEFAULT_IV_LENGTH)\n  const cipher = await crypto.subtle.encrypt(\n    { name: CRYPTO_DEFAULT_ALG, iv: ensureUint8Array(iv) },\n    key,\n    ensureUint8Array(data),\n  )\n  const binCypher = new Uint8Array(cipher)\n  const bufferLength = MAGIC_ID.length + iv.length + binCypher.length\n  const buffer = new Uint8Array(bufferLength)\n  let pos = 0\n  buffer.set(MAGIC_ID, pos)\n  pos += MAGIC_ID.length\n  buffer.set(iv, pos)\n  pos += iv.length\n  buffer.set(binCypher, pos)\n  return buffer\n}\n\nexport async function decrypt(\n  data: Uint8Array,\n  key: CryptoKey,\n): Promise<Uint8Array> {\n  const magic = ensureUint8Array(data.subarray(0, 2))\n  if (!equalBinary(magic, getMagicId()))\n    return Promise.reject(new Error(`Unknown magic ${magic}`))\n\n  const iv = ensureUint8Array(data.subarray(2, 2 + CRYPTO_DEFAULT_IV_LENGTH))\n  const cipher = ensureUint8Array(data.subarray(2 + CRYPTO_DEFAULT_IV_LENGTH, data.length))\n  const plain = await crypto.subtle.decrypt(\n    { name: CRYPTO_DEFAULT_ALG, iv },\n    key,\n    cipher,\n  )\n  return new Uint8Array(plain)\n}\n"],"mappings":";;;;AAIA,SAAgB,iBAAiB,SAAS,IAAgB;CACxD,MAAM,cAAc,IAAI,WAAW,OAAO;AAC1C,KAAI,OAAO,WAAW,eAAe,OAAO,gBAC1C,QAAO,gBAAgB,YAAY;KAKnC,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,IAG1B,aAAY,KAAK,KAAK,MAAM,KAAK,QAAQ,GAAG,IAAM;AAGtD,QAAO;;AAGT,MAAa,0BAA0B;AACvC,MAAa,qBAAqB;AAClC,MAAa,4BAA4B;AACzC,MAAa,mCAAmC;AAChD,MAAa,2BAA2B;AAExC,eAAsB,OACpB,SACA,YAAiC,yBACZ;CACrB,MAAM,IAAI,iBAAiB,aAAa,QAAQ,CAAC;AACjD,QAAO,aACL,MAAM,OAAO,OAAO,OAAO,WAAW,EAAE,CACzC;;AAGH,eAAsB,gBACpB,QACA,MAGI,EAAE,EACc;CACpB,MAAM,eAAe,iBAAiB,aAAa,OAAO,CAAC;CAC3D,MAAM,cAAc,MAAM,OAAO,OAAO,UACtC,OACA,cACA,2BACA,OACA,CAAC,YAAY,CACd;AACD,QAAO,MAAM,OAAO,OAAO,UACzB;EACE,MAAM;EACN,MAAM,IAAI,OAAO,iBAAiB,aAAa,IAAI,KAAK,CAAC,GAAG,IAAI,WAAW,EAAE;EAC7E,YAAY,IAAI;EAChB,MAAM;EACP,EACD,aACA;EACE,MAAM;EACN,QAAQ;EACT,EACD,MACA,CAAC,WAAW,UAAU,CACvB;;AAGH,eAAsB,mBACpB,QACA,MAGI,EAAE,EACc;CACpB,MAAM,eAAe,iBAAiB,aAAa,OAAO,CAAC;CAC3D,MAAM,cAAc,MAAM,OAAO,OAAO,UACtC,OACA,cACA,2BACA,OACA,CAAC,YAAY,CACd;AACD,QAAO,MAAM,OAAO,OAAO,UACzB;EACE,MAAM;EACN,MAAM,IAAI,OAAO,iBAAiB,aAAa,IAAI,KAAK,CAAC,GAAG,IAAI,WAAW,EAAE;EAC7E,YAAY,IAAI;EAChB,MAAM;EACP,EACD,aACA;EACE,MAAM;EACN,QAAQ;EACT,EACD,MACA,CAAC,WAAW,UAAU,CACvB;;AAGH,SAAS,aAAa;AACpB,QAAO,IAAI,WAAW,CAAC,GAAG,EAAE,CAAC;;AAG/B,eAAsB,QACpB,MACA,KACqB;CACrB,MAAM,WAAW,YAAY;CAC7B,MAAM,KAAK,oBAA0C;CACrD,MAAM,SAAS,MAAM,OAAO,OAAO,QACjC;EAAE,MAAM;EAAoB,IAAI,iBAAiB,GAAG;EAAE,EACtD,KACA,iBAAiB,KAAK,CACvB;CACD,MAAM,YAAY,IAAI,WAAW,OAAO;CACxC,MAAM,eAAe,SAAS,SAAS,GAAG,SAAS,UAAU;CAC7D,MAAM,SAAS,IAAI,WAAW,aAAa;CAC3C,IAAI,MAAM;AACV,QAAO,IAAI,UAAU,IAAI;AACzB,QAAO,SAAS;AAChB,QAAO,IAAI,IAAI,IAAI;AACnB,QAAO,GAAG;AACV,QAAO,IAAI,WAAW,IAAI;AAC1B,QAAO;;AAGT,eAAsB,QACpB,MACA,KACqB;CACrB,MAAM,QAAQ,iBAAiB,KAAK,SAAS,GAAG,EAAE,CAAC;AACnD,KAAI,CAAC,YAAY,OAAO,YAAY,CAAC,CACnC,QAAO,QAAQ,uBAAO,IAAI,MAAM,iBAAiB,QAAQ,CAAC;CAE5D,MAAM,KAAK,iBAAiB,KAAK,SAAS,GAAG,OAA6B,CAAC;CAC3E,MAAM,SAAS,iBAAiB,KAAK,SAAS,QAA8B,KAAK,OAAO,CAAC;CACzF,MAAM,QAAQ,MAAM,OAAO,OAAO,QAChC;EAAE,MAAM;EAAoB;EAAI,EAChC,KACA,OACD;AACD,QAAO,IAAI,WAAW,MAAM"}

package/dist/common/crypto/index.cjs

@@ -1,2 +1,23 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../../chunk-5VHLMAKU.cjs');var _chunkL5IXZXHRcjs = require('../../chunk-L5IXZXHR.cjs');var _chunkLUPESR7Scjs = require('../../chunk-LUPESR7S.cjs');var _chunkA6DSKTWFcjs = require('../../chunk-A6DSKTWF.cjs');require('../../chunk-TNMEWZPW.cjs');require('../../chunk-5RHVNJKM.cjs');require('../../chunk-P7XCQ7WV.cjs');exports.CRYPTO_DEFAULT_ALG = _chunkLUPESR7Scjs.c; exports.CRYPTO_DEFAULT_DERIVE_ALG = _chunkLUPESR7Scjs.d; exports.CRYPTO_DEFAULT_DERIVE_ITERATIONS = _chunkLUPESR7Scjs.e; exports.CRYPTO_DEFAULT_HASH_ALG = _chunkLUPESR7Scjs.b; exports.CRYPTO_DEFAULT_IV_LENGTH = _chunkLUPESR7Scjs.f; exports.decrypt = _chunkLUPESR7Scjs.k; exports.decryptAesGcm = _chunkL5IXZXHRcjs.b; exports.decryptXAES = _chunkA6DSKTWFcjs.b; exports.deriveKeyPbkdf2 = _chunkLUPESR7Scjs.h; exports.deriveKeyPbkdf2CBC = _chunkLUPESR7Scjs.i; exports.digest = _chunkLUPESR7Scjs.g; exports.encrypt = _chunkLUPESR7Scjs.j; exports.encryptAesGcm = _chunkL5IXZXHRcjs.a; exports.encryptXAES = _chunkA6DSKTWFcjs.a; exports.exportKeyXAES = _chunkA6DSKTWFcjs.e; exports.generateKeyXAES = _chunkA6DSKTWFcjs.c; exports.importKeyXAES = _chunkA6DSKTWFcjs.d; exports.randomUint8Array = _chunkLUPESR7Scjs.a;
-//# sourceMappingURL=index.cjs.map
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_common_crypto_aes_sealed = require('./aes-sealed.cjs');
+const require_common_crypto_crypto = require('./crypto.cjs');
+const require_common_crypto_xaes = require('./xaes.cjs');
+
+exports.CRYPTO_DEFAULT_ALG = require_common_crypto_crypto.CRYPTO_DEFAULT_ALG;
+exports.CRYPTO_DEFAULT_DERIVE_ALG = require_common_crypto_crypto.CRYPTO_DEFAULT_DERIVE_ALG;
+exports.CRYPTO_DEFAULT_DERIVE_ITERATIONS = require_common_crypto_crypto.CRYPTO_DEFAULT_DERIVE_ITERATIONS;
+exports.CRYPTO_DEFAULT_HASH_ALG = require_common_crypto_crypto.CRYPTO_DEFAULT_HASH_ALG;
+exports.CRYPTO_DEFAULT_IV_LENGTH = require_common_crypto_crypto.CRYPTO_DEFAULT_IV_LENGTH;
+exports.decrypt = require_common_crypto_crypto.decrypt;
+exports.decryptAesGcm = require_common_crypto_aes_sealed.decryptAesGcm;
+exports.decryptXAES = require_common_crypto_xaes.decryptXAES;
+exports.deriveKeyPbkdf2 = require_common_crypto_crypto.deriveKeyPbkdf2;
+exports.deriveKeyPbkdf2CBC = require_common_crypto_crypto.deriveKeyPbkdf2CBC;
+exports.digest = require_common_crypto_crypto.digest;
+exports.encrypt = require_common_crypto_crypto.encrypt;
+exports.encryptAesGcm = require_common_crypto_aes_sealed.encryptAesGcm;
+exports.encryptXAES = require_common_crypto_xaes.encryptXAES;
+exports.exportKeyXAES = require_common_crypto_xaes.exportKeyXAES;
+exports.generateKeyXAES = require_common_crypto_xaes.generateKeyXAES;
+exports.importKeyXAES = require_common_crypto_xaes.importKeyXAES;
+exports.randomUint8Array = require_common_crypto_crypto.randomUint8Array;

package/dist/common/crypto/index.d.cts

@@ -1,4 +1,4 @@
-export { decryptAesGcm, encryptAesGcm } from './aes-sealed.cjs';
-export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, randomUint8Array } from './crypto.cjs';
-export { decryptXAES, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES } from './xaes.cjs';
-import '../data/bin-types.cjs';
+import { n as encryptAesGcm, t as decryptAesGcm } from "../../aes-sealed-Q4saTGg2.cjs";
+import { a as CRYPTO_DEFAULT_IV_LENGTH, c as deriveKeyPbkdf2CBC, d as randomUint8Array, i as CRYPTO_DEFAULT_HASH_ALG, l as digest, n as CRYPTO_DEFAULT_DERIVE_ALG, o as decrypt, r as CRYPTO_DEFAULT_DERIVE_ITERATIONS, s as deriveKeyPbkdf2, t as CRYPTO_DEFAULT_ALG, u as encrypt } from "../../crypto-C8VaLy62.cjs";
+import { a as importKeyXAES, i as generateKeyXAES, n as encryptXAES, r as exportKeyXAES, t as decryptXAES } from "../../xaes-BuoCo_7y.cjs";
+export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, decryptAesGcm, decryptXAES, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, encryptAesGcm, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES, randomUint8Array };

package/dist/common/crypto/index.d.mts

@@ -0,0 +1,4 @@
+import { n as encryptAesGcm, t as decryptAesGcm } from "../../aes-sealed-CEgjlCzA.mjs";
+import { a as CRYPTO_DEFAULT_IV_LENGTH, c as deriveKeyPbkdf2CBC, d as randomUint8Array, i as CRYPTO_DEFAULT_HASH_ALG, l as digest, n as CRYPTO_DEFAULT_DERIVE_ALG, o as decrypt, r as CRYPTO_DEFAULT_DERIVE_ITERATIONS, s as deriveKeyPbkdf2, t as CRYPTO_DEFAULT_ALG, u as encrypt } from "../../crypto-D4uSzFEL.mjs";
+import { a as importKeyXAES, i as generateKeyXAES, n as encryptXAES, r as exportKeyXAES, t as decryptXAES } from "../../xaes-CTLXxroU.mjs";
+export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, decryptAesGcm, decryptXAES, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, encryptAesGcm, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES, randomUint8Array };

package/dist/common/crypto/index.mjs

@@ -0,0 +1,5 @@
+import { decryptAesGcm, encryptAesGcm } from "./aes-sealed.mjs";
+import { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, randomUint8Array } from "./crypto.mjs";
+import { decryptXAES, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES } from "./xaes.mjs";
+
+export { CRYPTO_DEFAULT_ALG, CRYPTO_DEFAULT_DERIVE_ALG, CRYPTO_DEFAULT_DERIVE_ITERATIONS, CRYPTO_DEFAULT_HASH_ALG, CRYPTO_DEFAULT_IV_LENGTH, decrypt, decryptAesGcm, decryptXAES, deriveKeyPbkdf2, deriveKeyPbkdf2CBC, digest, encrypt, encryptAesGcm, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES, randomUint8Array };

package/dist/common/crypto/xaes.cjs

@@ -1,2 +1,129 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkA6DSKTWFcjs = require('../../chunk-A6DSKTWF.cjs');require('../../chunk-TNMEWZPW.cjs');require('../../chunk-5RHVNJKM.cjs');require('../../chunk-P7XCQ7WV.cjs');exports.decryptXAES = _chunkA6DSKTWFcjs.b; exports.encryptXAES = _chunkA6DSKTWFcjs.a; exports.exportKeyXAES = _chunkA6DSKTWFcjs.e; exports.generateKeyXAES = _chunkA6DSKTWFcjs.c; exports.importKeyXAES = _chunkA6DSKTWFcjs.d;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_bin = require('../../bin-Ddaz2lxM.cjs');
+
+//#region src/common/crypto/xaes.ts
+/**
+* Implementation of XAES-256-GCM as defined in https://c2sp.org/XAES-256-GCM
+* based on the Web Cryptography API (https://www.w3.org/TR/WebCryptoAPI/).
+*
+* It uses a 256-bit AES-CBC CryptoKey and a 192-bit nonce to derive
+* a 256-bit key and a 96-bit nonce for AES-GCM.
+*
+* Due to the use of the standard CryptoKey and Web Cryptography API operations,
+* this implementation is fully compatible with other parts of the Web Cryptography API.
+* For example, keys can be stored in IndexedDB and be non-extractable. The only
+* additional requirement is that the key must have 'encrypt' usage even for decryption,
+* however, there's no real distinction between encryption and decryption operations
+* for AES-GCM anyway (you can simulate decryption by encrypting the ciphertext).
+*/
+/**
+* Generates an AES block using the given key and data xored with the given xor.
+*/
+async function aesBlock(key, data, xor) {
+	const block = await crypto.subtle.encrypt({
+		name: "AES-CBC",
+		iv: xor
+	}, key, data);
+	return new Uint8Array(block, 0, 16);
+}
+/**
+* Derives a half key.
+*/
+async function halfKey(index, key, iv, k1) {
+	const m = new Uint8Array(16);
+	m[1] = index;
+	m[2] = 88;
+	m.set(require_bin.ensureUint8Array(iv.subarray(0, 12)), 4);
+	return await aesBlock(key, m, require_bin.ensureUint8Array(k1));
+}
+/**
+* Derives a 256-bit key and 96-bit nonce from the given 256-bit key and a 192-bit nonce.
+*/
+async function deriveKeyNonce(key, iv) {
+	if (key.algorithm.name !== "AES-CBC") throw new Error("key must be for AES-CBC");
+	if (!key.usages.includes("encrypt")) throw new Error("key must have 'encrypt' usage");
+	if (key.algorithm.length !== 256) throw new Error("key must be 256 bits");
+	if (iv == null || iv.byteLength !== 24) throw new Error("iv must be 24 bytes");
+	const ivBytes = ArrayBuffer.isView(iv) ? new Uint8Array(iv.buffer, iv.byteOffset, iv.byteLength) : new Uint8Array(iv);
+	const k1 = await aesBlock(key, new Uint8Array(16), new Uint8Array(16));
+	let msb = 0;
+	for (let i = k1.length - 1; i >= 0; i--) [msb, k1[i]] = [k1[i] >>> 7 & 255, (k1[i] << 1 | msb) & 255];
+	k1[k1.length - 1] ^= msb * 135 & 255;
+	const kxBytes = new Uint8Array(32);
+	kxBytes.set(await halfKey(1, key, ivBytes, k1), 0);
+	kxBytes.set(await halfKey(2, key, ivBytes, k1), 16);
+	return {
+		key: await crypto.subtle.importKey("raw", kxBytes, {
+			name: "AES-GCM",
+			length: 256
+		}, false, [...key.usages]),
+		iv: require_bin.ensureUint8Array(ivBytes.subarray(12))
+	};
+}
+/**
+* Encrypts data using XAES-256-GCM with the given key and iv.
+* Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' usage.
+*/
+async function encryptXAES(params, key, data) {
+	const derived = await deriveKeyNonce(key, params.iv);
+	return await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv: derived.iv,
+		tagLength: 128,
+		additionalData: params.additionalData ?? new Uint8Array()
+	}, derived.key, data);
+}
+/**
+* Decrypts data using XAES-256-GCM with the given key and iv.
+* Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' and 'decrypt' usages.
+*/
+async function decryptXAES(params, key, data) {
+	const derived = await deriveKeyNonce(key, params.iv);
+	return await crypto.subtle.decrypt({
+		name: "AES-GCM",
+		iv: derived.iv,
+		tagLength: 128,
+		additionalData: params.additionalData ?? new Uint8Array()
+	}, derived.key, data);
+}
+/**
+* Generate a random key suitable for XAES-256-GCM.
+* The actual key is an AES-CBC CryptoKey with 256-bit length.
+*
+* This function is not necessary, as you can use crypto.subtle.generateKey with AES-CBC directly.
+*/
+async function generateKeyXAES(extractable) {
+	return await crypto.subtle.generateKey({
+		name: "AES-CBC",
+		length: 256
+	}, extractable, ["encrypt", "decrypt"]);
+}
+/**
+* Import a key suitable for XAES-256-GCM.
+* The actual key must be an AES-CBC CryptoKey with 256-bit length.
+*
+* This function is not necessary, as you can use crypto.subtle.importKey with AES-CBC directly.
+*/
+async function importKeyXAES(format, keyData, extractable) {
+	return await crypto.subtle.importKey(format, keyData, {
+		name: "AES-CBC",
+		length: 256
+	}, extractable, ["encrypt", "decrypt"]);
+}
+/**
+* Export a key.
+* The resulting export will have AES-CBC algorithm specified.
+*
+* This function is not necessary, as you can use crypto.subtle.exportKey directly.
+*/
+async function exportKeyXAES(format, key) {
+	return await crypto.subtle.exportKey(format, key);
+}
+
+//#endregion
+exports.decryptXAES = decryptXAES;
+exports.encryptXAES = encryptXAES;
+exports.exportKeyXAES = exportKeyXAES;
+exports.generateKeyXAES = generateKeyXAES;
+exports.importKeyXAES = importKeyXAES;
 //# sourceMappingURL=xaes.cjs.map

package/dist/common/crypto/xaes.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/crypto/xaes.cjs"],"names":[],"mappings":"AAAA,qIAA+C,oCAAiC,oCAAiC,oCAAiC,8NAAqG","file":"/Users/dirk/work/github-zeed/dist/common/crypto/xaes.cjs"}
+{"version":3,"file":"xaes.cjs","names":["ensureUint8Array"],"sources":["../../../src/common/crypto/xaes.ts"],"sourcesContent":["// Original at https://github.com/dchest/xaes MIT License as of 2024-07-02\n// More at https://words.filippo.io/dispatches/xaes-256-gcm/\n\nimport { ensureUint8Array } from '../data/bin'\n\n/**\n * Implementation of XAES-256-GCM as defined in https://c2sp.org/XAES-256-GCM\n * based on the Web Cryptography API (https://www.w3.org/TR/WebCryptoAPI/).\n *\n * It uses a 256-bit AES-CBC CryptoKey and a 192-bit nonce to derive\n * a 256-bit key and a 96-bit nonce for AES-GCM.\n *\n * Due to the use of the standard CryptoKey and Web Cryptography API operations,\n * this implementation is fully compatible with other parts of the Web Cryptography API.\n * For example, keys can be stored in IndexedDB and be non-extractable. The only\n * additional requirement is that the key must have 'encrypt' usage even for decryption,\n * however, there's no real distinction between encryption and decryption operations\n * for AES-GCM anyway (you can simulate decryption by encrypting the ciphertext).\n */\n\n/**\n * Generates an AES block using the given key and data xored with the given xor.\n */\nasync function aesBlock(key: CryptoKey, data: BufferSource, xor: BufferSource): Promise<Uint8Array> {\n  const block = await crypto.subtle.encrypt(\n    { name: 'AES-CBC', iv: xor },\n    key,\n    data,\n  )\n  return new Uint8Array(block, 0, 16)\n}\n\n/**\n * Derives a half key.\n */\nasync function halfKey(index: number, key: CryptoKey, iv: Uint8Array, k1: Uint8Array): Promise<Uint8Array> {\n  const m = new Uint8Array(16)\n  m[1] = index\n  m[2] = 0x58 // 'X'\n  m.set(ensureUint8Array(iv.subarray(0, 12)), 4)\n  return await aesBlock(key, m, ensureUint8Array(k1))\n}\n\n/**\n * Derives a 256-bit key and 96-bit nonce from the given 256-bit key and a 192-bit nonce.\n */\nasync function deriveKeyNonce(key: CryptoKey, iv: BufferSource): Promise<{ key: CryptoKey, iv: Uint8Array }> {\n  if (key.algorithm.name !== 'AES-CBC') {\n    throw new Error('key must be for AES-CBC')\n  }\n  if (!key.usages.includes('encrypt')) {\n    throw new Error('key must have \\'encrypt\\' usage')\n  }\n  // @ts-expect-error todo\n  if (key.algorithm.length !== 256) {\n    throw new Error('key must be 256 bits')\n  }\n  if (iv == null || iv.byteLength !== 24) {\n    throw new Error('iv must be 24 bytes')\n  }\n  const ivBytes = ArrayBuffer.isView(iv)\n    ? new Uint8Array(iv.buffer, iv.byteOffset, iv.byteLength)\n    : new Uint8Array(iv)\n  const k1 = await aesBlock(key, new Uint8Array(16), new Uint8Array(16))\n\n  let msb = 0\n  for (let i = k1.length - 1; i >= 0; i--) {\n    [msb, k1[i]] = [(k1[i] >>> 7) & 0xFF, ((k1[i] << 1) | msb) & 0xFF]\n  }\n  k1[k1.length - 1] ^= (msb * 0b10000111) & 0xFF\n\n  const kxBytes = new Uint8Array(32)\n  kxBytes.set(await halfKey(0x01, key, ivBytes, k1), 0)\n  kxBytes.set(await halfKey(0x02, key, ivBytes, k1), 16)\n\n  const kx = await crypto.subtle.importKey(\n    'raw',\n    kxBytes,\n    { name: 'AES-GCM', length: 256 },\n    false,\n    [...key.usages],\n  )\n  return {\n    key: kx,\n    iv: ensureUint8Array(ivBytes.subarray(12)),\n  }\n}\n/**\n * Encrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' usage.\n */\nexport async function encryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Decrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' and 'decrypt' usages.\n */\nexport async function decryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.decrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Generate a random key suitable for XAES-256-GCM.\n * The actual key is an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.generateKey with AES-CBC directly.\n */\nexport async function generateKeyXAES(extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.generateKey(\n    {\n      name: 'AES-CBC',\n      // @ts-expect-error todo\n      length: 256,\n    },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Import a key suitable for XAES-256-GCM.\n * The actual key must be an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.importKey with AES-CBC directly.\n */\nexport async function importKeyXAES(format: 'jwk' | 'raw' | 'pkcs8' | 'spki', keyData: BufferSource | JsonWebKey, extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.importKey( // @ts-expect-error-next-line\n    format,\n    keyData,\n    { name: 'AES-CBC', length: 256 },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Export a key.\n * The resulting export will have AES-CBC algorithm specified.\n *\n * This function is not necessary, as you can use crypto.subtle.exportKey directly.\n */\nexport async function exportKeyXAES(format: 'jwk' | 'pkcs8' | 'raw' | 'spki', key: CryptoKey): Promise<ArrayBuffer | JsonWebKey> {\n  return await crypto.subtle.exportKey(format, key)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAuBA,eAAe,SAAS,KAAgB,MAAoB,KAAwC;CAClG,MAAM,QAAQ,MAAM,OAAO,OAAO,QAChC;EAAE,MAAM;EAAW,IAAI;EAAK,EAC5B,KACA,KACD;AACD,QAAO,IAAI,WAAW,OAAO,GAAG,GAAG;;;;;AAMrC,eAAe,QAAQ,OAAe,KAAgB,IAAgB,IAAqC;CACzG,MAAM,IAAI,IAAI,WAAW,GAAG;AAC5B,GAAE,KAAK;AACP,GAAE,KAAK;AACP,GAAE,IAAIA,6BAAiB,GAAG,SAAS,GAAG,GAAG,CAAC,EAAE,EAAE;AAC9C,QAAO,MAAM,SAAS,KAAK,GAAGA,6BAAiB,GAAG,CAAC;;;;;AAMrD,eAAe,eAAe,KAAgB,IAA+D;AAC3G,KAAI,IAAI,UAAU,SAAS,UACzB,OAAM,IAAI,MAAM,0BAA0B;AAE5C,KAAI,CAAC,IAAI,OAAO,SAAS,UAAU,CACjC,OAAM,IAAI,MAAM,gCAAkC;AAGpD,KAAI,IAAI,UAAU,WAAW,IAC3B,OAAM,IAAI,MAAM,uBAAuB;AAEzC,KAAI,MAAM,QAAQ,GAAG,eAAe,GAClC,OAAM,IAAI,MAAM,sBAAsB;CAExC,MAAM,UAAU,YAAY,OAAO,GAAG,GAClC,IAAI,WAAW,GAAG,QAAQ,GAAG,YAAY,GAAG,WAAW,GACvD,IAAI,WAAW,GAAG;CACtB,MAAM,KAAK,MAAM,SAAS,KAAK,IAAI,WAAW,GAAG,EAAE,IAAI,WAAW,GAAG,CAAC;CAEtE,IAAI,MAAM;AACV,MAAK,IAAI,IAAI,GAAG,SAAS,GAAG,KAAK,GAAG,IAClC,EAAC,KAAK,GAAG,MAAM,CAAE,GAAG,OAAO,IAAK,MAAQ,GAAG,MAAM,IAAK,OAAO,IAAK;AAEpE,IAAG,GAAG,SAAS,MAAO,MAAM,MAAc;CAE1C,MAAM,UAAU,IAAI,WAAW,GAAG;AAClC,SAAQ,IAAI,MAAM,QAAQ,GAAM,KAAK,SAAS,GAAG,EAAE,EAAE;AACrD,SAAQ,IAAI,MAAM,QAAQ,GAAM,KAAK,SAAS,GAAG,EAAE,GAAG;AAStD,QAAO;EACL,KARS,MAAM,OAAO,OAAO,UAC7B,OACA,SACA;GAAE,MAAM;GAAW,QAAQ;GAAK,EAChC,OACA,CAAC,GAAG,IAAI,OAAO,CAChB;EAGC,IAAIA,6BAAiB,QAAQ,SAAS,GAAG,CAAC;EAC3C;;;;;;AAMH,eAAsB,YAAY,QAG/B,KAAgB,MAA0C;CAC3D,MAAM,UAAU,MAAM,eAAe,KAAK,OAAO,GAAG;AACpD,QAAO,MAAM,OAAO,OAAO,QACzB;EACE,MAAM;EACN,IAAI,QAAQ;EACZ,WAAW;EACX,gBAAgB,OAAO,kBAAkB,IAAI,YAAY;EAC1D,EACD,QAAQ,KACR,KACD;;;;;;AAOH,eAAsB,YAAY,QAG/B,KAAgB,MAA0C;CAC3D,MAAM,UAAU,MAAM,eAAe,KAAK,OAAO,GAAG;AACpD,QAAO,MAAM,OAAO,OAAO,QACzB;EACE,MAAM;EACN,IAAI,QAAQ;EACZ,WAAW;EACX,gBAAgB,OAAO,kBAAkB,IAAI,YAAY;EAC1D,EACD,QAAQ,KACR,KACD;;;;;;;;AASH,eAAsB,gBAAgB,aAA2C;AAC/E,QAAO,MAAM,OAAO,OAAO,YACzB;EACE,MAAM;EAEN,QAAQ;EACT,EACD,aACA,CAAC,WAAW,UAAU,CACvB;;;;;;;;AASH,eAAsB,cAAc,QAA0C,SAAoC,aAA2C;AAC3J,QAAO,MAAM,OAAO,OAAO,UACzB,QACA,SACA;EAAE,MAAM;EAAW,QAAQ;EAAK,EAChC,aACA,CAAC,WAAW,UAAU,CACvB;;;;;;;;AASH,eAAsB,cAAc,QAA0C,KAAmD;AAC/H,QAAO,MAAM,OAAO,OAAO,UAAU,QAAQ,IAAI"}

package/dist/common/crypto/xaes.d.cts

@@ -1,39 +1,2 @@
-/**
- * Encrypts data using XAES-256-GCM with the given key and iv.
- * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' usage.
- */
-declare function encryptXAES(params: {
-    iv: BufferSource;
-    additionalData?: BufferSource;
-}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
-/**
- * Decrypts data using XAES-256-GCM with the given key and iv.
- * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' and 'decrypt' usages.
- */
-declare function decryptXAES(params: {
-    iv: BufferSource;
-    additionalData?: BufferSource;
-}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
-/**
- * Generate a random key suitable for XAES-256-GCM.
- * The actual key is an AES-CBC CryptoKey with 256-bit length.
- *
- * This function is not necessary, as you can use crypto.subtle.generateKey with AES-CBC directly.
- */
-declare function generateKeyXAES(extractable?: boolean): Promise<CryptoKey>;
-/**
- * Import a key suitable for XAES-256-GCM.
- * The actual key must be an AES-CBC CryptoKey with 256-bit length.
- *
- * This function is not necessary, as you can use crypto.subtle.importKey with AES-CBC directly.
- */
-declare function importKeyXAES(format: 'jwk' | 'raw' | 'pkcs8' | 'spki', keyData: BufferSource | JsonWebKey, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Export a key.
- * The resulting export will have AES-CBC algorithm specified.
- *
- * This function is not necessary, as you can use crypto.subtle.exportKey directly.
- */
-declare function exportKeyXAES(format: 'jwk' | 'pkcs8' | 'raw' | 'spki', key: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
-
-export { decryptXAES, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES };
+import { a as importKeyXAES, i as generateKeyXAES, n as encryptXAES, r as exportKeyXAES, t as decryptXAES } from "../../xaes-BuoCo_7y.cjs";
+export { decryptXAES, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES };

package/dist/common/crypto/xaes.d.mts

@@ -0,0 +1,2 @@
+import { a as importKeyXAES, i as generateKeyXAES, n as encryptXAES, r as exportKeyXAES, t as decryptXAES } from "../../xaes-CTLXxroU.mjs";
+export { decryptXAES, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES };