@ocap/mcrypto 1.27.16 → 1.28.1

package/esm/signer/secp256k1.js

@@ -1,95 +1,82 @@
-import elliptic from 'elliptic';
-import { BN, stripHexPrefix, toHex, toBuffer, toUint8Array } from '@ocap/util';
-import randomBytes from 'randombytes';
-import Signer from '../protocols/signer';
-import { encode } from '../encode';
-/* eslint-disable class-methods-use-this */
-/* eslint-disable no-useless-constructor */
+import { encode } from "../encode.js";
+import signer_default from "../protocols/signer.js";
+import { BN, stripHexPrefix, toBuffer, toHex, toUint8Array } from "@ocap/util";
+import randomBytes from "randombytes";
+import elliptic from "elliptic";
+
+//#region src/signer/secp256k1.ts
 const EC = elliptic.ec;
-const secp256k1 = new EC('secp256k1');
+const secp256k1 = new EC("secp256k1");
 /**
- * Signer implementation for secp256k1, based on `elliptic`
- *
- * @class Secp256k1Signer
- */
-class Secp256k1Signer extends Signer {
-    constructor() {
-        super();
-        this.pkHasFormatPrefix = true;
-        this.pkCompressed = false;
-    }
-    isValidSK(sk) {
-        if (sk.byteLength !== 32) {
-            return false;
-        }
-        const bn = new BN(sk);
-        return bn.cmp(secp256k1.curve.n) < 0 && !bn.isZero();
-    }
-    /**
-     * @public
-     * @typedefKeyPairType
-     * @prop {string} publicKey - publicKey in hex format
-     * @prop {string} secretKey - secretKey in hex format
-     * @memberof Secp256k1Signer
-     */
-    /**
-     * Generate random secret/public key pair
-     */
-    genKeyPair(encoding = 'hex') {
-        let sk = null;
-        do {
-            sk = new Uint8Array(randomBytes(32));
-        } while (!this.isValidSK(sk));
-        const pk = this.getPublicKey(toHex(sk));
-        return { secretKey: encode(sk, encoding), publicKey: encode(pk, encoding) };
-    }
-    /**
-     * Get publicKey from secretKey
-     */
-    getPublicKey(sk, encoding = 'hex') {
-        if (!this.isValidSK(toUint8Array(sk))) {
-            throw new Error('Invalid secret key');
-        }
-        let pk = secp256k1.keyFromPrivate(toBuffer(sk)).getPublic(this.pkCompressed, 'hex');
-        if (this.pkHasFormatPrefix === false) {
-            pk = pk.slice(2);
-        }
-        return encode(`0x${pk}`, encoding);
-    }
-    /**
-     * Sign a message and get the signature hex
-     */
-    sign(message, sk, encoding = 'hex') {
-        let msg = message;
-        try {
-            msg = toUint8Array(message);
-        }
-        catch (err) {
-            // Do nothing;
-        }
-        const signature = secp256k1
-            .keyFromPrivate(toBuffer(sk))
-            .sign(stripHexPrefix(msg), { canonical: true })
-            .toDER('hex');
-        return encode(`0x${signature}`, encoding);
-    }
-    /**
-     * Verify if a signature is valid
-     */
-    verify(message, signature, pk) {
-        let msg = message;
-        try {
-            msg = toUint8Array(message);
-        }
-        catch (err) {
-            // Do nothing;
-        }
-        let pkBuffer = toBuffer(pk);
-        if (this.pkHasFormatPrefix === false && pkBuffer[0] !== 0x04 && pkBuffer.byteLength === 64) {
-            pkBuffer = Buffer.concat([Buffer.from([0x04]), pkBuffer]);
-        }
-        return secp256k1.keyFromPublic(pkBuffer).verify(stripHexPrefix(msg), stripHexPrefix(toHex(signature)));
-    }
-}
-export default new Secp256k1Signer();
-export { Secp256k1Signer };
+* Signer implementation for secp256k1, based on `elliptic`
+*
+* @class Secp256k1Signer
+*/
+var Secp256k1Signer = class extends signer_default {
+	constructor() {
+		super();
+		this.pkHasFormatPrefix = true;
+		this.pkCompressed = false;
+	}
+	isValidSK(sk) {
+		if (sk.byteLength !== 32) return false;
+		const bn = new BN(sk);
+		return bn.cmp(secp256k1.curve.n) < 0 && !bn.isZero();
+	}
+	/**
+	* @public
+	* @typedefKeyPairType
+	* @prop {string} publicKey - publicKey in hex format
+	* @prop {string} secretKey - secretKey in hex format
+	* @memberof Secp256k1Signer
+	*/
+	/**
+	* Generate random secret/public key pair
+	*/
+	genKeyPair(encoding = "hex") {
+		let sk = null;
+		do
+			sk = new Uint8Array(randomBytes(32));
+		while (!this.isValidSK(sk));
+		const pk = this.getPublicKey(toHex(sk));
+		return {
+			secretKey: encode(sk, encoding),
+			publicKey: encode(pk, encoding)
+		};
+	}
+	/**
+	* Get publicKey from secretKey
+	*/
+	getPublicKey(sk, encoding = "hex") {
+		if (!this.isValidSK(toUint8Array(sk))) throw new Error("Invalid secret key");
+		let pk = secp256k1.keyFromPrivate(toBuffer(sk)).getPublic(this.pkCompressed, "hex");
+		if (this.pkHasFormatPrefix === false) pk = pk.slice(2);
+		return encode(`0x${pk}`, encoding);
+	}
+	/**
+	* Sign a message and get the signature hex
+	*/
+	sign(message, sk, encoding = "hex") {
+		let msg = message;
+		try {
+			msg = toUint8Array(message);
+		} catch (err) {}
+		return encode(`0x${secp256k1.keyFromPrivate(toBuffer(sk)).sign(stripHexPrefix(msg), { canonical: true }).toDER("hex")}`, encoding);
+	}
+	/**
+	* Verify if a signature is valid
+	*/
+	verify(message, signature, pk) {
+		let msg = message;
+		try {
+			msg = toUint8Array(message);
+		} catch (err) {}
+		let pkBuffer = toBuffer(pk);
+		if (this.pkHasFormatPrefix === false && pkBuffer[0] !== 4 && pkBuffer.byteLength === 64) pkBuffer = Buffer.concat([Buffer.from([4]), pkBuffer]);
+		return secp256k1.keyFromPublic(pkBuffer).verify(stripHexPrefix(msg), stripHexPrefix(toHex(signature)));
+	}
+};
+var secp256k1_default = new Secp256k1Signer();
+
+//#endregion
+export { Secp256k1Signer, secp256k1_default as default };

package/lib/_virtual/rolldown_runtime.js

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/lib/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/lib/crypter/aes-legacy.js

@@ -1,55 +1,38 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AesCrypter = void 0;
-const AES = __importStar(require("crypto-js/aes"));
-const enc_latin1_1 = __importDefault(require("crypto-js/enc-latin1"));
-const enc_utf8_1 = __importDefault(require("crypto-js/enc-utf8"));
-const enc_utf16_1 = __importDefault(require("crypto-js/enc-utf16"));
-const enc_base64_1 = __importDefault(require("crypto-js/enc-base64"));
-const enc_hex_1 = __importDefault(require("crypto-js/enc-hex"));
-const crypter_1 = __importDefault(require("../protocols/crypter"));
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_protocols_crypter = require('../protocols/crypter.js');
+let crypto_js_aes = require("crypto-js/aes");
+crypto_js_aes = require_rolldown_runtime.__toESM(crypto_js_aes);
+let crypto_js_enc_latin1 = require("crypto-js/enc-latin1");
+crypto_js_enc_latin1 = require_rolldown_runtime.__toESM(crypto_js_enc_latin1);
+let crypto_js_enc_utf8 = require("crypto-js/enc-utf8");
+crypto_js_enc_utf8 = require_rolldown_runtime.__toESM(crypto_js_enc_utf8);
+let crypto_js_enc_utf16 = require("crypto-js/enc-utf16");
+crypto_js_enc_utf16 = require_rolldown_runtime.__toESM(crypto_js_enc_utf16);
+let crypto_js_enc_base64 = require("crypto-js/enc-base64");
+crypto_js_enc_base64 = require_rolldown_runtime.__toESM(crypto_js_enc_base64);
+let crypto_js_enc_hex = require("crypto-js/enc-hex");
+crypto_js_enc_hex = require_rolldown_runtime.__toESM(crypto_js_enc_hex);
+
+//#region src/crypter/aes-legacy.ts
 const encoders = {
-    latin1: enc_latin1_1.default,
-    utf8: enc_utf8_1.default,
-    hex: enc_hex_1.default,
-    utf16: enc_utf16_1.default,
-    base64: enc_base64_1.default,
+	latin1: crypto_js_enc_latin1.default,
+	utf8: crypto_js_enc_utf8.default,
+	hex: crypto_js_enc_hex.default,
+	utf16: crypto_js_enc_utf16.default,
+	base64: crypto_js_enc_base64.default
+};
+var AesCrypter = class extends require_protocols_crypter.default {
+	encrypt(message, secret) {
+		const text = typeof message === "string" ? message : JSON.stringify(message);
+		return crypto_js_aes.encrypt(text, secret).toString();
+	}
+	decrypt(cipher, secret, outputEncoding = "utf8") {
+		return crypto_js_aes.decrypt(cipher, secret).toString(encoders[outputEncoding]);
+	}
 };
-// AES-CBC-256
-class AesCrypter extends crypter_1.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
 exports.AesCrypter = AesCrypter;
-exports.default = new AesCrypter();
+exports.default = aes_legacy_default;

package/lib/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/lib/crypter/aes.js

@@ -1,31 +1,31 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_encode = require('../encode.js');
+const require_hasher_sha3 = require('../hasher/sha3.js');
+const require_protocols_crypter = require('../protocols/crypter.js');
+let _ocap_util = require("@ocap/util");
+let crypto = require("crypto");
+crypto = require_rolldown_runtime.__toESM(crypto);
+
+//#region src/crypter/aes.ts
+var AesCrypter = class extends require_protocols_crypter.default {
+	encrypt(message, secret, encoding = "hex") {
+		const key = require_hasher_sha3.default.hash256(secret, 1, "buffer");
+		const cipher = crypto.default.createCipheriv("aes-256-ecb", key, "");
+		cipher.setAutoPadding(true);
+		const output = cipher.update((0, _ocap_util.toBuffer)(message));
+		return require_encode.encode(Buffer.concat([output, cipher.final()]), encoding);
+	}
+	decrypt(message, secret, encoding = "hex") {
+		const key = require_hasher_sha3.default.hash256(secret, 1, "buffer");
+		const decipher = crypto.default.createDecipheriv("aes-256-ecb", key, "");
+		decipher.setAutoPadding(true);
+		const output = decipher.update((0, _ocap_util.toBuffer)(message));
+		return require_encode.encode(Buffer.concat([output, decipher.final()]), encoding);
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AesCrypter = void 0;
-// For browsers, may need: https://www.npmjs.com/package/crypto-browserify
-const crypto_1 = __importDefault(require("crypto"));
-const util_1 = require("@ocap/util");
-const crypter_1 = __importDefault(require("../protocols/crypter"));
-const sha3_1 = __importDefault(require("../hasher/sha3"));
-const encode_1 = require("../encode");
-// AES-ECB-256
-class AesCrypter extends crypter_1.default {
-    encrypt(message, secret, encoding = 'hex') {
-        const key = sha3_1.default.hash256(secret, 1, 'buffer');
-        const cipher = crypto_1.default.createCipheriv('aes-256-ecb', key, '');
-        cipher.setAutoPadding(true);
-        const output = cipher.update((0, util_1.toBuffer)(message));
-        return (0, encode_1.encode)(Buffer.concat([output, cipher.final()]), encoding);
-    }
-    decrypt(message, secret, encoding = 'hex') {
-        const key = sha3_1.default.hash256(secret, 1, 'buffer');
-        const decipher = crypto_1.default.createDecipheriv('aes-256-ecb', key, '');
-        decipher.setAutoPadding(true);
-        const output = decipher.update((0, util_1.toBuffer)(message));
-        return (0, encode_1.encode)(Buffer.concat([output, decipher.final()]), encoding);
-    }
-}
+var aes_default = new AesCrypter();
+
+//#endregion
 exports.AesCrypter = AesCrypter;
-exports.default = new AesCrypter();
+exports.default = aes_default;

package/lib/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/lib/crypter/rsa-browserify.js

@@ -1,36 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RSABrowserCrypter = void 0;
-// 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
-const util_1 = require("@ocap/util");
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+let _ocap_util = require("@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 (0, util_1.toBase58)(new Uint8Array(encrypted));
-    }
-    async decrypt(message, key) {
-        const decrypted = await crypto.decrypt({ name: RSA_ALGORITHM }, key, (0, util_1.fromBase58)(message));
-        return Buffer.from(new Uint8Array(decrypted)).toString('utf8');
-    }
-}
+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 (0, _ocap_util.toBase58)(new Uint8Array(encrypted));
+	}
+	async decrypt(message, key) {
+		const decrypted = await crypto.decrypt({ name: RSA_ALGORITHM }, key, (0, _ocap_util.fromBase58)(message));
+		return Buffer.from(new Uint8Array(decrypted)).toString("utf8");
+	}
+};
+var rsa_browserify_default = new RSABrowserCrypter();
+
+//#endregion
 exports.RSABrowserCrypter = RSABrowserCrypter;
-exports.default = new RSABrowserCrypter();
+exports.default = rsa_browserify_default;

package/lib/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/lib/crypter/rsa.js

@@ -1,34 +1,35 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_encode = require('../encode.js');
+const require_protocols_crypter = require('../protocols/crypter.js');
+let _ocap_util = require("@ocap/util");
+let crypto = require("crypto");
+crypto = require_rolldown_runtime.__toESM(crypto);
+
+//#region src/crypter/rsa.ts
+var RSACrypter = class extends require_protocols_crypter.default {
+	genKeyPair(length = 2048) {
+		return crypto.default.generateKeyPairSync("rsa", {
+			modulusLength: length,
+			publicKeyEncoding: {
+				type: "spki",
+				format: "pem"
+			},
+			privateKeyEncoding: {
+				type: "pkcs8",
+				format: "pem"
+			}
+		});
+	}
+	encrypt(message, key, encoding = "hex") {
+		return require_encode.encode(crypto.default.publicEncrypt(key, (0, _ocap_util.toBuffer)(message)), encoding);
+	}
+	decrypt(message, key, encoding = "hex") {
+		return require_encode.encode(crypto.default.privateDecrypt(key, (0, _ocap_util.toBuffer)(message)), encoding);
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RSACrypter = void 0;
-const crypto_1 = __importDefault(require("crypto"));
-const util_1 = require("@ocap/util");
-const crypter_1 = __importDefault(require("../protocols/crypter"));
-const encode_1 = require("../encode");
-// RSA-OAEP
-class RSACrypter extends crypter_1.default {
-    genKeyPair(length = 2048) {
-        return crypto_1.default.generateKeyPairSync('rsa', {
-            modulusLength: length,
-            publicKeyEncoding: {
-                type: 'spki',
-                format: 'pem',
-            },
-            privateKeyEncoding: {
-                type: 'pkcs8',
-                format: 'pem',
-            },
-        });
-    }
-    encrypt(message, key, encoding = 'hex') {
-        return (0, encode_1.encode)(crypto_1.default.publicEncrypt(key, (0, util_1.toBuffer)(message)), encoding);
-    }
-    decrypt(message, key, encoding = 'hex') {
-        return (0, encode_1.encode)(crypto_1.default.privateDecrypt(key, (0, util_1.toBuffer)(message)), encoding);
-    }
-}
+var rsa_default = new RSACrypter();
+
+//#endregion
 exports.RSACrypter = RSACrypter;
-exports.default = new RSACrypter();
+exports.default = rsa_default;

package/lib/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/lib/encode.js

@@ -1,22 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encode = encode;
-const util_1 = require("@ocap/util");
-function encode(data, encoding = 'hex') {
-    if (['hex', 'base16'].includes(encoding)) {
-        return (0, util_1.toHex)(data);
-    }
-    if (encoding === 'base58') {
-        return (0, util_1.toBase58)(data);
-    }
-    if (encoding === 'base64') {
-        return (0, util_1.toBase64)(data);
-    }
-    if (encoding === 'Uint8Array') {
-        return (0, util_1.toUint8Array)(data);
-    }
-    if (encoding === 'buffer') {
-        return (0, util_1.toBuffer)(data);
-    }
-    return data;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let _ocap_util = require("@ocap/util");
+
+//#region src/encode.ts
+function encode(data, encoding = "hex") {
+	if (["hex", "base16"].includes(encoding)) return (0, _ocap_util.toHex)(data);
+	if (encoding === "base58") return (0, _ocap_util.toBase58)(data);
+	if (encoding === "base64") return (0, _ocap_util.toBase64)(data);
+	if (encoding === "Uint8Array") return (0, _ocap_util.toUint8Array)(data);
+	if (encoding === "buffer") return (0, _ocap_util.toBuffer)(data);
+	return data;
 }
+
+//#endregion
+exports.encode = encode;