@ocap/mcrypto 1.27.16 → 1.28.1

package/esm/crypter/aes-legacy.d.ts

@@ -1,8 +1,10 @@
-import Crypter from '../protocols/crypter';
-declare class AesCrypter extends Crypter {
-    encrypt(message: string | object, secret: string): string;
-    decrypt(cipher: string, secret: string, outputEncoding?: string): string;
+import _default$1 from "../protocols/crypter.js";
+
+//#region src/crypter/aes-legacy.d.ts
+declare class AesCrypter extends _default$1 {
+  encrypt(message: string | object, secret: string): string;
+  decrypt(cipher: string, secret: string, outputEncoding?: string): string;
 }
 declare const _default: AesCrypter;
-export default _default;
-export { AesCrypter };
+//#endregion
+export { AesCrypter, _default as default };

package/esm/crypter/aes-legacy.js

@@ -1,26 +1,29 @@
-import * as AES from 'crypto-js/aes';
-import encLatin1 from 'crypto-js/enc-latin1';
-import encUtf8 from 'crypto-js/enc-utf8';
-import encUtf16 from 'crypto-js/enc-utf16';
-import encBase64 from 'crypto-js/enc-base64';
-import encHex from 'crypto-js/enc-hex';
-import Crypter from '../protocols/crypter';
+import crypter_default from "../protocols/crypter.js";
+import * as AES from "crypto-js/aes.js";
+import encLatin1 from "crypto-js/enc-latin1.js";
+import encUtf8 from "crypto-js/enc-utf8.js";
+import encUtf16 from "crypto-js/enc-utf16.js";
+import encBase64 from "crypto-js/enc-base64.js";
+import encHex from "crypto-js/enc-hex.js";
+
+//#region src/crypter/aes-legacy.ts
 const encoders = {
-    latin1: encLatin1,
-    utf8: encUtf8,
-    hex: encHex,
-    utf16: encUtf16,
-    base64: encBase64,
+	latin1: encLatin1,
+	utf8: encUtf8,
+	hex: encHex,
+	utf16: encUtf16,
+	base64: encBase64
 };
-// AES-CBC-256
-class AesCrypter extends Crypter {
-    encrypt(message, secret) {
-        const text = typeof message === 'string' ? message : JSON.stringify(message);
-        return AES.encrypt(text, secret).toString();
-    }
-    decrypt(cipher, secret, outputEncoding = 'utf8') {
-        return AES.decrypt(cipher, secret).toString(encoders[outputEncoding]);
-    }
-}
-export default new AesCrypter();
-export { AesCrypter };
+var AesCrypter = class extends crypter_default {
+	encrypt(message, secret) {
+		const text = typeof message === "string" ? message : JSON.stringify(message);
+		return AES.encrypt(text, secret).toString();
+	}
+	decrypt(cipher, secret, outputEncoding = "utf8") {
+		return AES.decrypt(cipher, secret).toString(encoders[outputEncoding]);
+	}
+};
+var aes_legacy_default = new AesCrypter();
+
+//#endregion
+export { AesCrypter, aes_legacy_default as default };

package/esm/crypter/aes.d.ts

@@ -1,9 +1,11 @@
-import { BytesType, EncodingType } from '@ocap/util';
-import Crypter from '../protocols/crypter';
-declare class AesCrypter extends Crypter {
-    encrypt(message: BytesType, secret: BytesType, encoding?: EncodingType): BytesType;
-    decrypt(message: BytesType, secret: BytesType, encoding?: EncodingType): BytesType;
+import _default$1 from "../protocols/crypter.js";
+import { BytesType, EncodingType } from "@ocap/util";
+
+//#region src/crypter/aes.d.ts
+declare class AesCrypter extends _default$1 {
+  encrypt(message: BytesType, secret: BytesType, encoding?: EncodingType): BytesType;
+  decrypt(message: BytesType, secret: BytesType, encoding?: EncodingType): BytesType;
 }
 declare const _default: AesCrypter;
-export default _default;
-export { AesCrypter };
+//#endregion
+export { AesCrypter, _default as default };

package/esm/crypter/aes.js

@@ -1,25 +1,27 @@
-// For browsers, may need: https://www.npmjs.com/package/crypto-browserify
-import crypto from 'crypto';
-import { toBuffer } from '@ocap/util';
-import Crypter from '../protocols/crypter';
-import SHA3 from '../hasher/sha3';
-import { encode } from '../encode';
-// AES-ECB-256
-class AesCrypter extends Crypter {
-    encrypt(message, secret, encoding = 'hex') {
-        const key = SHA3.hash256(secret, 1, 'buffer');
-        const cipher = crypto.createCipheriv('aes-256-ecb', key, '');
-        cipher.setAutoPadding(true);
-        const output = cipher.update(toBuffer(message));
-        return encode(Buffer.concat([output, cipher.final()]), encoding);
-    }
-    decrypt(message, secret, encoding = 'hex') {
-        const key = SHA3.hash256(secret, 1, 'buffer');
-        const decipher = crypto.createDecipheriv('aes-256-ecb', key, '');
-        decipher.setAutoPadding(true);
-        const output = decipher.update(toBuffer(message));
-        return encode(Buffer.concat([output, decipher.final()]), encoding);
-    }
-}
-export default new AesCrypter();
-export { AesCrypter };
+import { encode } from "../encode.js";
+import sha3_default from "../hasher/sha3.js";
+import crypter_default from "../protocols/crypter.js";
+import { toBuffer } from "@ocap/util";
+import crypto from "crypto";
+
+//#region src/crypter/aes.ts
+var AesCrypter = class extends crypter_default {
+	encrypt(message, secret, encoding = "hex") {
+		const key = sha3_default.hash256(secret, 1, "buffer");
+		const cipher = crypto.createCipheriv("aes-256-ecb", key, "");
+		cipher.setAutoPadding(true);
+		const output = cipher.update(toBuffer(message));
+		return encode(Buffer.concat([output, cipher.final()]), encoding);
+	}
+	decrypt(message, secret, encoding = "hex") {
+		const key = sha3_default.hash256(secret, 1, "buffer");
+		const decipher = crypto.createDecipheriv("aes-256-ecb", key, "");
+		decipher.setAutoPadding(true);
+		const output = decipher.update(toBuffer(message));
+		return encode(Buffer.concat([output, decipher.final()]), encoding);
+	}
+};
+var aes_default = new AesCrypter();
+
+//#endregion
+export { AesCrypter, aes_default as default };

package/esm/crypter/rsa-browserify.d.ts

@@ -1,9 +1,10 @@
+//#region src/crypter/rsa-browserify.d.ts
 declare class RSABrowserCrypter {
-    genKeyPair(length?: number): Promise<CryptoKeyPair>;
-    formatPublicKey(key: CryptoKey): Promise<string>;
-    encrypt(message: string, key: CryptoKey): Promise<string>;
-    decrypt(message: string, key: CryptoKey): Promise<string>;
+  genKeyPair(length?: number): Promise<CryptoKeyPair>;
+  formatPublicKey(key: CryptoKey): Promise<string>;
+  encrypt(message: string, key: CryptoKey): Promise<string>;
+  decrypt(message: string, key: CryptoKey): Promise<string>;
 }
 declare const _default: RSABrowserCrypter;
-export default _default;
-export { RSABrowserCrypter };
+//#endregion
+export { RSABrowserCrypter, _default as default };

package/esm/crypter/rsa-browserify.js

@@ -1,33 +1,36 @@
-// https://stackoverflow.com/questions/70056340/how-can-i-generate-an-rsa-pair-that-works-both-in-node-js-and-browser
-// https://stackoverflow.com/questions/62948516/using-native-javascript-subtlecrypto-to-encrypt-using-rsa
-import { fromBase58, toBase58 } from '@ocap/util';
+import { fromBase58, toBase58 } from "@ocap/util";
+
+//#region src/crypter/rsa-browserify.ts
 const crypto = window.crypto.subtle;
-// @ts-ignore
 const ab2str = (buffer) => String.fromCharCode.apply(null, new Uint8Array(buffer));
-const RSA_ALGORITHM = 'RSA-OAEP';
-// RSA-OAEP
-class RSABrowserCrypter {
-    genKeyPair(length = 2048) {
-        return crypto.generateKey({
-            name: RSA_ALGORITHM,
-            modulusLength: length,
-            publicExponent: new Uint8Array([1, 0, 1]),
-            hash: 'SHA-256',
-        }, true, ['encrypt', 'decrypt']);
-    }
-    async formatPublicKey(key) {
-        const exported = await crypto.exportKey('spki', key);
-        const base64 = window.btoa(ab2str(exported));
-        return `-----BEGIN PUBLIC KEY-----\n${base64}\n-----END PUBLIC KEY-----`;
-    }
-    async encrypt(message, key) {
-        const encrypted = await crypto.encrypt({ name: RSA_ALGORITHM }, key, new TextEncoder().encode(message));
-        return toBase58(new Uint8Array(encrypted));
-    }
-    async decrypt(message, key) {
-        const decrypted = await crypto.decrypt({ name: RSA_ALGORITHM }, key, fromBase58(message));
-        return Buffer.from(new Uint8Array(decrypted)).toString('utf8');
-    }
-}
-export default new RSABrowserCrypter();
-export { RSABrowserCrypter };
+const RSA_ALGORITHM = "RSA-OAEP";
+var RSABrowserCrypter = class {
+	genKeyPair(length = 2048) {
+		return crypto.generateKey({
+			name: RSA_ALGORITHM,
+			modulusLength: length,
+			publicExponent: new Uint8Array([
+				1,
+				0,
+				1
+			]),
+			hash: "SHA-256"
+		}, true, ["encrypt", "decrypt"]);
+	}
+	async formatPublicKey(key) {
+		const exported = await crypto.exportKey("spki", key);
+		return `-----BEGIN PUBLIC KEY-----\n${window.btoa(ab2str(exported))}\n-----END PUBLIC KEY-----`;
+	}
+	async encrypt(message, key) {
+		const encrypted = await crypto.encrypt({ name: RSA_ALGORITHM }, key, new TextEncoder().encode(message));
+		return toBase58(new Uint8Array(encrypted));
+	}
+	async decrypt(message, key) {
+		const decrypted = await crypto.decrypt({ name: RSA_ALGORITHM }, key, fromBase58(message));
+		return Buffer.from(new Uint8Array(decrypted)).toString("utf8");
+	}
+};
+var rsa_browserify_default = new RSABrowserCrypter();
+
+//#endregion
+export { RSABrowserCrypter, rsa_browserify_default as default };

package/esm/crypter/rsa.d.ts

@@ -1,11 +1,13 @@
-import crypto from 'crypto';
-import { BytesType, EncodingType } from '@ocap/util';
-import Crypter from '../protocols/crypter';
-declare class RSACrypter extends Crypter {
-    genKeyPair(length?: number): crypto.KeyPairSyncResult<string, string>;
-    encrypt(message: BytesType, key: string, encoding?: EncodingType): BytesType;
-    decrypt(message: BytesType, key: string, encoding?: EncodingType): BytesType;
+import _default$1 from "../protocols/crypter.js";
+import { BytesType, EncodingType } from "@ocap/util";
+import crypto from "crypto";
+
+//#region src/crypter/rsa.d.ts
+declare class RSACrypter extends _default$1 {
+  genKeyPair(length?: number): crypto.KeyPairSyncResult<string, string>;
+  encrypt(message: BytesType, key: string, encoding?: EncodingType): BytesType;
+  decrypt(message: BytesType, key: string, encoding?: EncodingType): BytesType;
 }
 declare const _default: RSACrypter;
-export default _default;
-export { RSACrypter };
+//#endregion
+export { RSACrypter, _default as default };

package/esm/crypter/rsa.js

@@ -1,28 +1,31 @@
-import crypto from 'crypto';
-import { toBuffer } from '@ocap/util';
-import Crypter from '../protocols/crypter';
-import { encode } from '../encode';
-// RSA-OAEP
-class RSACrypter extends Crypter {
-    genKeyPair(length = 2048) {
-        return crypto.generateKeyPairSync('rsa', {
-            modulusLength: length,
-            publicKeyEncoding: {
-                type: 'spki',
-                format: 'pem',
-            },
-            privateKeyEncoding: {
-                type: 'pkcs8',
-                format: 'pem',
-            },
-        });
-    }
-    encrypt(message, key, encoding = 'hex') {
-        return encode(crypto.publicEncrypt(key, toBuffer(message)), encoding);
-    }
-    decrypt(message, key, encoding = 'hex') {
-        return encode(crypto.privateDecrypt(key, toBuffer(message)), encoding);
-    }
-}
-export default new RSACrypter();
-export { RSACrypter };
+import { encode } from "../encode.js";
+import crypter_default from "../protocols/crypter.js";
+import { toBuffer } from "@ocap/util";
+import crypto from "crypto";
+
+//#region src/crypter/rsa.ts
+var RSACrypter = class extends crypter_default {
+	genKeyPair(length = 2048) {
+		return crypto.generateKeyPairSync("rsa", {
+			modulusLength: length,
+			publicKeyEncoding: {
+				type: "spki",
+				format: "pem"
+			},
+			privateKeyEncoding: {
+				type: "pkcs8",
+				format: "pem"
+			}
+		});
+	}
+	encrypt(message, key, encoding = "hex") {
+		return encode(crypto.publicEncrypt(key, toBuffer(message)), encoding);
+	}
+	decrypt(message, key, encoding = "hex") {
+		return encode(crypto.privateDecrypt(key, toBuffer(message)), encoding);
+	}
+};
+var rsa_default = new RSACrypter();
+
+//#endregion
+export { RSACrypter, rsa_default as default };

package/esm/encode.d.ts

@@ -1,8 +1,12 @@
-import { BytesType, EncodingType } from '@ocap/util';
-export declare function encode(data: BytesType, encoding?: 'hex'): string;
-export declare function encode(data: BytesType, encoding?: 'base16'): string;
-export declare function encode(data: BytesType, encoding?: 'base58'): string;
-export declare function encode(data: BytesType, encoding?: 'base64'): string;
-export declare function encode(data: BytesType, encoding?: 'buffer'): Buffer;
-export declare function encode(data: BytesType, encoding?: 'Uint8Array'): Uint8Array;
-export declare function encode(data: BytesType, encoding?: EncodingType): BytesType;
+import { BytesType, EncodingType } from "@ocap/util";
+
+//#region src/encode.d.ts
+declare function encode(data: BytesType, encoding?: 'hex'): string;
+declare function encode(data: BytesType, encoding?: 'base16'): string;
+declare function encode(data: BytesType, encoding?: 'base58'): string;
+declare function encode(data: BytesType, encoding?: 'base64'): string;
+declare function encode(data: BytesType, encoding?: 'buffer'): Buffer;
+declare function encode(data: BytesType, encoding?: 'Uint8Array'): Uint8Array;
+declare function encode(data: BytesType, encoding?: EncodingType): BytesType;
+//#endregion
+export { encode };

package/esm/encode.js

@@ -1,19 +1,14 @@
-import { toHex, toUint8Array, toBase58, toBase64, toBuffer } from '@ocap/util';
-export function encode(data, encoding = 'hex') {
-    if (['hex', 'base16'].includes(encoding)) {
-        return toHex(data);
-    }
-    if (encoding === 'base58') {
-        return toBase58(data);
-    }
-    if (encoding === 'base64') {
-        return toBase64(data);
-    }
-    if (encoding === 'Uint8Array') {
-        return toUint8Array(data);
-    }
-    if (encoding === 'buffer') {
-        return toBuffer(data);
-    }
-    return data;
+import { toBase58, toBase64, toBuffer, toHex, toUint8Array } from "@ocap/util";
+
+//#region src/encode.ts
+function encode(data, encoding = "hex") {
+	if (["hex", "base16"].includes(encoding)) return toHex(data);
+	if (encoding === "base58") return toBase58(data);
+	if (encoding === "base64") return toBase64(data);
+	if (encoding === "Uint8Array") return toUint8Array(data);
+	if (encoding === "buffer") return toBuffer(data);
+	return data;
 }
+
+//#endregion
+export { encode };

package/esm/hasher/keccak.d.ts

@@ -1,13 +1,16 @@
-import { BytesType, EncodingType } from '@ocap/util';
+import { BytesType, EncodingType } from "@ocap/util";
+
+//#region src/hasher/keccak.d.ts
+
 /**
  * Keccak support with different hash length
  *
  * @class KeccakHasher
  */
 declare class KeccakHasher {
-    [x: string]: (data: BytesType, round?: number, encoding?: EncodingType) => BytesType;
-    constructor();
+  [x: string]: (data: BytesType, round?: number, encoding?: EncodingType) => BytesType;
+  constructor();
 }
 declare const _default: KeccakHasher;
-export default _default;
-export { KeccakHasher };
+//#endregion
+export { KeccakHasher, _default as default };

package/esm/hasher/keccak.js

@@ -1,37 +1,38 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import sha3 from 'js-sha3';
-import { toUint8Array } from '@ocap/util';
-import { encode } from '../encode';
+import { encode } from "../encode.js";
+import { toUint8Array } from "@ocap/util";
+import sha3 from "js-sha3";
+
+//#region src/hasher/keccak.ts
 /**
- * Keccak support with different hash length
- *
- * @class KeccakHasher
- */
-class KeccakHasher {
-    constructor() {
-        [224, 256, 384, 512].forEach((x) => {
-            const name = `hash${x}`;
-            // @ts-ignore
-            const hasher = (data) => sha3[`keccak${x}`](data);
-            const hashFn = (input, round) => {
-                if (round === 1) {
-                    return hasher(input);
-                }
-                return hashFn(hasher(input), round - 1);
-            };
-            this[name] = (data, round = 1, encoding = 'hex') => {
-                let input = data;
-                try {
-                    input = toUint8Array(data);
-                }
-                catch (err) {
-                    // Do nothing
-                }
-                const res = hashFn(input, round);
-                return encode(`0x${res}`, encoding);
-            };
-        });
-    }
-}
-export default new KeccakHasher();
-export { KeccakHasher };
+* Keccak support with different hash length
+*
+* @class KeccakHasher
+*/
+var KeccakHasher = class {
+	constructor() {
+		[
+			224,
+			256,
+			384,
+			512
+		].forEach((x) => {
+			const name = `hash${x}`;
+			const hasher = (data) => sha3[`keccak${x}`](data);
+			const hashFn = (input, round) => {
+				if (round === 1) return hasher(input);
+				return hashFn(hasher(input), round - 1);
+			};
+			this[name] = (data, round = 1, encoding = "hex") => {
+				let input = data;
+				try {
+					input = toUint8Array(data);
+				} catch (err) {}
+				return encode(`0x${hashFn(input, round)}`, encoding);
+			};
+		});
+	}
+};
+var keccak_default = new KeccakHasher();
+
+//#endregion
+export { KeccakHasher, keccak_default as default };

package/esm/hasher/sha2.d.ts

@@ -1,13 +1,16 @@
-import { BytesType, EncodingType } from '@ocap/util';
+import { BytesType, EncodingType } from "@ocap/util";
+
+//#region src/hasher/sha2.d.ts
+
 /**
  * Sha2 support with different hash length
  *
  * @class
  */
 declare class Sha2Hasher {
-    [x: string]: (data: BytesType, round?: number, encoding?: EncodingType) => BytesType;
-    constructor();
+  [x: string]: (data: BytesType, round?: number, encoding?: EncodingType) => BytesType;
+  constructor();
 }
 declare const _default: Sha2Hasher;
-export default _default;
-export { Sha2Hasher };
+//#endregion
+export { Sha2Hasher, _default as default };

package/esm/hasher/sha2.js

@@ -1,43 +1,45 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import { toUint8Array } from '@ocap/util';
-import { sha224, sha256, sha384, sha512 } from 'hash.js';
-import { encode } from '../encode';
+import { encode } from "../encode.js";
+import { toUint8Array } from "@ocap/util";
+import _hash_js from "hash.js";
+const { sha224, sha256, sha384, sha512 } = _hash_js;
+
+//#region src/hasher/sha2.ts
 const hashFns = {
-    sha224,
-    sha256,
-    sha384,
-    sha512,
+	sha224,
+	sha256,
+	sha384,
+	sha512
 };
 /**
- * Sha2 support with different hash length
- *
- * @class
- */
-class Sha2Hasher {
-    constructor() {
-        [224, 256, 384, 512].forEach((x) => {
-            const name = `hash${x}`;
-            // @ts-ignore
-            const hasher = hashFns[`sha${x}`];
-            const hashFn = (input, round) => {
-                let inputBytes = input;
-                try {
-                    inputBytes = toUint8Array(input);
-                }
-                catch (err) {
-                    // Do nothing
-                }
-                if (round === 1) {
-                    return `0x${hasher().update(inputBytes).digest('hex')}`;
-                }
-                return hashFn(hashFn(inputBytes, 1), round - 1);
-            };
-            this[name] = (data, round = 2, encoding = 'hex') => {
-                const res = hashFn(data, round);
-                return encode(res, encoding);
-            };
-        });
-    }
-}
-export default new Sha2Hasher();
-export { Sha2Hasher };
+* Sha2 support with different hash length
+*
+* @class
+*/
+var Sha2Hasher = class {
+	constructor() {
+		[
+			224,
+			256,
+			384,
+			512
+		].forEach((x) => {
+			const name = `hash${x}`;
+			const hasher = hashFns[`sha${x}`];
+			const hashFn = (input, round) => {
+				let inputBytes = input;
+				try {
+					inputBytes = toUint8Array(input);
+				} catch (err) {}
+				if (round === 1) return `0x${hasher().update(inputBytes).digest("hex")}`;
+				return hashFn(hashFn(inputBytes, 1), round - 1);
+			};
+			this[name] = (data, round = 2, encoding = "hex") => {
+				return encode(hashFn(data, round), encoding);
+			};
+		});
+	}
+};
+var sha2_default = new Sha2Hasher();
+
+//#endregion
+export { Sha2Hasher, sha2_default as default };

package/esm/hasher/sha3.d.ts

@@ -1,13 +1,16 @@
-import { BytesType, EncodingType } from '@ocap/util';
+import { BytesType, EncodingType } from "@ocap/util";
+
+//#region src/hasher/sha3.d.ts
+
 /**
  * Sha3 support with different hash length
  *
  * @class Sha3Hasher
  */
 declare class Sha3Hasher {
-    [x: string]: (data: BytesType, round?: number, encoding?: EncodingType) => BytesType;
-    constructor();
+  [x: string]: (data: BytesType, round?: number, encoding?: EncodingType) => BytesType;
+  constructor();
 }
 declare const _default: Sha3Hasher;
-export default _default;
-export { Sha3Hasher };
+//#endregion
+export { Sha3Hasher, _default as default };