ddan-js 2.6.37 → 2.6.39

package/bin/lib/modules/browser/ecdh.js

@@ -3,72 +3,114 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const convert_1 = require("../convert");
 class Ecdh {
     publicKey = '';
+    privateKey = '';
     iv = '';
-    __keyPair;
+    __privateCryptoKey;
     __sharedSecret;
     __curve;
-    constructor(curve = 'P-256') {
+    __keyFormat;
+    __subtle;
+    constructor(curve = 'P-256', keyFormat = 'raw') {
         this.__curve = curve;
+        this.__keyFormat = keyFormat || 'raw';
+        if (typeof window !== 'undefined')
+            this.__subtle = window.crypto.subtle;
+        else
+            this.__subtle = {};
     }
-    async generateKeys(iv) {
-        const keyPair = await window.crypto.subtle.generateKey({
+    async generateKeys() {
+        const keyPair = await this.__subtle.generateKey({
             name: 'ECDH',
             namedCurve: this.__curve, // 使用 P-256 椭圆曲线
         }, true, // 可以导出
         ['deriveKey', 'deriveBits']);
-        this.__keyPair = keyPair;
-        this.publicKey = await this.exportSpkiKey(keyPair.publicKey);
-        this.iv = iv;
+        this.__privateCryptoKey = keyPair.privateKey;
+        this.publicKey = await this.exportKey(keyPair.publicKey);
+        this.privateKey = await this.exportKey(keyPair.privateKey, 'pkcs8');
         return this;
     }
-    async exportSpkiKey(cryptoKey) {
-        const exportKey = await window.crypto.subtle.exportKey('spki', // 公钥的格式（适合交换的标准格式）
-        cryptoKey);
+    async exportKey(cryptoKey, keyFormat = 'raw') {
+        const exportKey = await this.__subtle.exportKey(keyFormat || this.__keyFormat, cryptoKey);
         return convert_1.default.ab2str(exportKey, true);
     }
-    async importSpkiKey(keyBase64) {
+    async importKey(keyBase64, keyFormat = 'raw', usages = []) {
         const bytes = convert_1.default.base64ToBytes(keyBase64);
-        const publicKey = await window.crypto.subtle.importKey('spki', bytes, {
+        const publicKey = await this.__subtle.importKey(keyFormat || this.__keyFormat || 'raw', bytes, {
             name: 'ECDH',
             namedCurve: this.__curve,
-        }, true, []);
+        }, true, usages);
         return publicKey;
     }
-    async deriveSharedSecret(publicKeyBase64) {
-        if (!this.__keyPair)
-            return this;
-        const publicKey = await this.importSpkiKey(publicKeyBase64);
-        const sharedSecret = await window.crypto.subtle.deriveKey({
+    async setPrivateKey(privateBase64) {
+        if (!privateBase64)
+            return false;
+        const cryptoKey = await this.importKey(privateBase64, 'pkcs8', ['deriveKey', 'deriveBits']);
+        this.privateKey = await this.exportKey(cryptoKey, 'pkcs8');
+        this.__privateCryptoKey = cryptoKey;
+        return true;
+    }
+    async deriveSharedSecret(publicKeyBase64, iv) {
+        if (!this.__privateCryptoKey)
+            return false;
+        this.iv = iv;
+        const cryptoKey = await this.importKey(publicKeyBase64);
+        const sharedSecret = await this.__subtle.deriveKey({
             name: 'ECDH',
-            public: publicKey, // 对方的公钥
-        }, this.__keyPair.privateKey, // 自己的私钥
+            public: cryptoKey, // 对方的公钥
+        }, this.__privateCryptoKey, // 自己的私钥
         { name: 'AES-GCM', length: 256 }, // 派生出的共享密钥用于 AES 加密
         true, // 可以导出
         ['encrypt', 'decrypt'] // 用于加密和解密
         );
         this.__sharedSecret = sharedSecret;
-        return this;
+        return true;
     }
     async encode(data) {
         if (!this.__sharedSecret || !this.iv)
-            return { text: '', iv: '' };
+            return '';
         const bytes = convert_1.default.textEncode(data);
-        const encrypted = await window.crypto.subtle.encrypt({
+        const encrypted = await this.__subtle.encrypt({
             name: 'AES-GCM',
             iv: convert_1.default.base64ToBytes(this.iv),
         }, this.__sharedSecret, bytes);
-        const b64 = convert_1.default.ab2str(encrypted, true);
-        return { iv: this.iv, text: b64 };
+        return convert_1.default.ab2str(encrypted, true);
+    }
+    async encodeiv(data) {
+        if (!this.__sharedSecret || !this.iv)
+            return '';
+        const dataBytes = convert_1.default.textEncode(data);
+        const ivBytes = convert_1.default.base64ToBytes(this.iv);
+        const encrypted = await this.__subtle.encrypt({
+            name: 'AES-GCM',
+            iv: ivBytes,
+        }, this.__sharedSecret, dataBytes);
+        const bytes = convert_1.default.concatBytes(new Uint8Array(encrypted), ivBytes);
+        return convert_1.default.bytesToBase64(bytes);
     }
     async decode(encrypted, iv) {
-        if (!this.__sharedSecret || !iv)
+        if (!this.__sharedSecret)
             return '';
-        const bytes = convert_1.default.str2ab(encrypted, true);
-        const decrypted = await window.crypto.subtle.decrypt({
+        const _iv = iv || this.iv;
+        const bytes = convert_1.default.base64ToBytes(encrypted);
+        const decrypted = await this.__subtle.decrypt({
             name: 'AES-GCM',
-            iv: convert_1.default.base64ToBytes(iv),
+            iv: convert_1.default.base64ToBytes(_iv),
         }, this.__sharedSecret, bytes);
         return convert_1.default.textDecode(decrypted);
     }
+    async decodeiv(encrypted) {
+        if (!this.__sharedSecret)
+            return '';
+        const bytes = convert_1.default.base64ToBytes(encrypted);
+        if (bytes.length < 12)
+            return '';
+        const ivBytes = bytes.slice(bytes.length - 12);
+        const dataBytes = bytes.slice(0, bytes.length - 12);
+        const decrypted = await this.__subtle.decrypt({
+            name: 'AES-GCM',
+            iv: ivBytes,
+        }, this.__sharedSecret, dataBytes);
+        return convert_1.default.textDecode(decrypted);
+    }
 }
 exports.default = Ecdh;

package/bin/lib/modules/convert/index.js

@@ -107,6 +107,20 @@ const toDataUrl = (textOrBuf, contentType = 'text/plain') => {
     }
     return '';
 };
+const concatBytes = (...args) => {
+    // 计算所有 Uint8Array 的总长度
+    const totalLength = args.reduce((sum, arr) => sum + arr.length, 0);
+    // 创建一个新的 Uint8Array
+    const combined = new Uint8Array(totalLength);
+    // 当前写入的位置
+    let offset = 0;
+    // 将每个 Uint8Array 复制到新的数组中
+    for (const arr of args) {
+        combined.set(arr, offset);
+        offset += arr.length;
+    }
+    return combined;
+};
 exports.default = {
     ...utf8_1.default,
     ...base64_1.default,
@@ -122,4 +136,5 @@ exports.default = {
     textEncode,
     textDecode,
     toDataUrl,
+    concatBytes,
 };

package/bin/lib/modules/node/ecdh-web.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = require("node:crypto");
+const ecdh_1 = require("../browser/ecdh");
+class EcdhWeb extends ecdh_1.default {
+    constructor(curve = "P-256", keyFormat = "raw") {
+        super(curve, keyFormat);
+        this.__subtle = node_crypto_1.default.webcrypto.subtle;
+    }
+}
+exports.default = EcdhWeb;

package/bin/lib/modules/node/ecdh.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = require("node:crypto");
 const convert_1 = require("../convert");
+const node_crypto_1 = require("node:crypto");
 class Ecdh {
     publicKey = '';
     privateKey = '';
     sharedSecret;
-    iv;
+    iv = '';
     _curve;
     _algorithm;
     _ecdh;
@@ -17,7 +17,7 @@ class Ecdh {
     }
     generateKey() {
         // 使用 P-256 曲线
-        const ecdh = node_crypto_1.default.createECDH(this._curve);
+        const ecdh = node_crypto_1.default.createECDH('prime256v1');
         ecdh.generateKeys();
         // 公钥以 base64 格式导出
         this.publicKey = ecdh.getPublicKey('base64');
@@ -26,32 +26,77 @@ class Ecdh {
         this._ecdh = ecdh;
     }
     deriveSharedSecret(otherPublicKey, iv) {
-        if (!otherPublicKey)
-            return undefined;
+        if (!otherPublicKey || !iv)
+            return false;
         this.sharedSecret = this._ecdh.computeSecret(otherPublicKey, 'base64').toString('base64');
         this.iv = iv;
-        return this;
+        return true;
+    }
+    setPrivateKey(privateBase64) {
+        if (!privateBase64)
+            return false;
+        if (!this._ecdh)
+            return false;
+        this._ecdh.setPrivateKey(privateBase64, 'base64');
+        this.publicKey = this._ecdh.getPublicKey('base64');
+        return true;
     }
     encode(data) {
         if (!this.sharedSecret || !this.iv)
-            return { text: '', authTag: '', iv: '' };
+            return '';
         const cipher = node_crypto_1.default.createCipheriv('aes-256-gcm', convert_1.default.base64ToBytes(this.sharedSecret), convert_1.default.base64ToBytes(this.iv));
-        const encrypted = cipher.update(data, 'utf8', 'base64') + cipher.final('base64');
+        const encrypted = Buffer.concat([
+            new Uint8Array(cipher.update(data, 'utf8')),
+            new Uint8Array(cipher.final()),
+        ]);
+        const tagBuf = cipher.getAuthTag();
+        const combined = Buffer.concat([new Uint8Array(encrypted), new Uint8Array(tagBuf)]);
+        return combined.toString('base64');
+    }
+    encodeiv(data) {
+        if (!this.sharedSecret || !this.iv)
+            return '';
+        const ivBytes = convert_1.default.base64ToBytes(this.iv);
+        const cipher = node_crypto_1.default.createCipheriv('aes-256-gcm', convert_1.default.base64ToBytes(this.sharedSecret), ivBytes);
+        const encrypted = Buffer.concat([
+            new Uint8Array(cipher.update(data, 'utf8')),
+            new Uint8Array(cipher.final()),
+        ]);
         const authTagBuf = cipher.getAuthTag();
-        const authTag = authTagBuf.toString('base64');
-        return {
-            text: encrypted,
-            authTag,
-            iv: this.iv,
-        };
-    }
-    decode(encrypted, authTag, iv) {
-        if (!encrypted || !this.sharedSecret || !iv || !authTag)
+        const combined = Buffer.concat([new Uint8Array(encrypted), new Uint8Array(authTagBuf), ivBytes]);
+        return combined.toString('base64');
+    }
+    decode(encrypted, iv) {
+        if (!encrypted || !this.sharedSecret)
+            return '';
+        const _iv = iv || this.iv;
+        const decipher = node_crypto_1.default.createDecipheriv('aes-256-gcm', convert_1.default.base64ToBytes(this.sharedSecret), convert_1.default.base64ToBytes(_iv));
+        const allBytes = convert_1.default.base64ToBytes(encrypted);
+        const authTagBytes = allBytes.slice(allBytes.length - 16);
+        decipher.setAuthTag(authTagBytes);
+        const encryptedBytes = allBytes.slice(0, allBytes.length - 16);
+        const decrypted = Buffer.concat([
+            new Uint8Array(decipher.update(encryptedBytes)),
+            new Uint8Array(decipher.final()),
+        ]);
+        return decrypted.toString('utf-8');
+    }
+    decodeiv(encrypted) {
+        if (!encrypted || !this.sharedSecret)
+            return '';
+        const allBytes = convert_1.default.base64ToBytes(encrypted);
+        if (allBytes.length < 28)
             return '';
-        const decipher = node_crypto_1.default.createDecipheriv('aes-256-gcm', convert_1.default.base64ToBytes(this.sharedSecret), convert_1.default.base64ToBytes(iv));
-        decipher.setAuthTag(convert_1.default.base64ToBytes(authTag));
-        const decrypted = decipher.update(encrypted, 'base64', 'utf8') + decipher.final('utf8');
-        return decrypted;
+        const ivBytes = allBytes.slice(allBytes.length - 12);
+        const tagBytes = allBytes.slice(allBytes.length - 28, allBytes.length - 12);
+        const decipher = node_crypto_1.default.createDecipheriv('aes-256-gcm', convert_1.default.base64ToBytes(this.sharedSecret), ivBytes);
+        decipher.setAuthTag(tagBytes);
+        const encryptedBytes = allBytes.slice(0, allBytes.length - 28);
+        const decrypted = Buffer.concat([
+            new Uint8Array(decipher.update(encryptedBytes)),
+            new Uint8Array(decipher.final()),
+        ]);
+        return decrypted.toString('utf-8');
     }
 }
 exports.default = Ecdh;

package/bin/lib/modules/node/index.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const brotli_1 = require("./brotli");
 const ecdh_1 = require("./ecdh");
-const ecdh_spki_1 = require("./ecdh-spki");
 const socks5_1 = require("./socks5");
 const child_1 = require("./child");
 const proxy_1 = require("./proxy");
-exports.default = { ...brotli_1.default, ...child_1.default, ...proxy_1.default, Ecdh: ecdh_1.default, EcdhSpki: ecdh_spki_1.default, Socks5: socks5_1.Socks5 };
+const ecdh_web_1 = require("./ecdh-web");
+exports.default = { ...brotli_1.default, ...child_1.default, ...proxy_1.default, Ecdh: ecdh_1.default, EcdhWeb: ecdh_web_1.default, Socks5: socks5_1.Socks5 };

package/bin/lib/modules/qs/index.js

@@ -88,7 +88,8 @@ const shExpMatch = (text, pattern) => {
         .replace(/\./g, '\\.') // 转义 .
         .replace(/\*/g, '.*') // 将 * 转换为 .*
         .replace(/\?/g, '.'); // 将 ? 转换为 .
-    const regex = new RegExp(regexPattern);
+    // const regex = new RegExp(regexPattern)
+    const regex = new RegExp('^' + regexPattern + '$');
     return regex.test(text);
 };
 exports.default = {

package/bin/types/index.d.ts

@@ -72,7 +72,7 @@ declare const dUtil: {
     keyChars: string;
     str2Hex: (str: string) => string;
     hex2Str: (hexstr: string) => string;
-    str2ab: (content?: string, base64?: boolean) => ArrayBufferLike;
+    str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
     ab2str: (data: ArrayBuffer, base64?: boolean) => string;
     bytesToStr: (bytes: Uint8Array) => string;
     strToBytes: (str?: string) => Uint8Array;
@@ -82,6 +82,7 @@ declare const dUtil: {
     textEncode: (text: string) => Uint8Array;
     textDecode: (buf: ArrayBuffer) => string;
     toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+    concatBytes: (...args: Uint8Array[]) => Uint8Array;
     toBase64: (input?: string) => string;
     fromBase64: (input?: string) => string;
     bytesToBase64: (bytes: Uint8Array) => string;
@@ -294,7 +295,7 @@ declare const dHook: {
     keyChars: string;
     str2Hex: (str: string) => string;
     hex2Str: (hexstr: string) => string;
-    str2ab: (content?: string, base64?: boolean) => ArrayBufferLike;
+    str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
     ab2str: (data: ArrayBuffer, base64?: boolean) => string;
     bytesToStr: (bytes: Uint8Array) => string;
     strToBytes: (str?: string) => Uint8Array;
@@ -304,6 +305,7 @@ declare const dHook: {
     textEncode: (text: string) => Uint8Array;
     textDecode: (buf: ArrayBuffer) => string;
     toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+    concatBytes: (...args: Uint8Array[]) => Uint8Array;
     toBase64: (input?: string) => string;
     fromBase64: (input?: string) => string;
     bytesToBase64: (bytes: Uint8Array) => string;
@@ -559,7 +561,7 @@ declare const dWeb: {
 };
 declare const dNode: {
     Ecdh: typeof import("./modules/node/ecdh").default;
-    EcdhSpki: typeof import("./modules/node/ecdh-spki").default;
+    EcdhWeb: typeof import("./modules/node/ecdh-web").default;
     Socks5: typeof import("./modules/node/socks5").Socks5;
     getSystemProxy: () => Promise<{
         ipaddress: string;
@@ -894,7 +896,7 @@ declare const _default: {
     convert: {
         str2Hex: (str: string) => string;
         hex2Str: (hexstr: string) => string;
-        str2ab: (content?: string, base64?: boolean) => ArrayBufferLike;
+        str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
         ab2str: (data: ArrayBuffer, base64?: boolean) => string;
         bytesToStr: (bytes: Uint8Array) => string;
         strToBytes: (str?: string) => Uint8Array;
@@ -904,6 +906,7 @@ declare const _default: {
         textEncode: (text: string) => Uint8Array;
         textDecode: (buf: ArrayBuffer) => string;
         toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+        concatBytes: (...args: Uint8Array[]) => Uint8Array;
         toBase64: (input?: string) => string;
         fromBase64: (input?: string) => string;
         bytesToBase64: (bytes: Uint8Array) => string;

package/bin/types/modules/browser/ecdh.d.ts

@@ -1,17 +1,21 @@
+export type TKeyFormat = 'raw' | 'pkcs8' | 'spki';
 export default class Ecdh {
     publicKey: string;
+    privateKey: string;
     iv: string;
-    __keyPair: CryptoKeyPair | undefined;
+    __privateCryptoKey: CryptoKey | undefined;
     __sharedSecret: CryptoKey | undefined;
     __curve: string;
-    constructor(curve?: string);
-    generateKeys(iv: string): Promise<this>;
-    exportSpkiKey(cryptoKey: CryptoKey): Promise<string>;
-    importSpkiKey(keyBase64: string): Promise<CryptoKey>;
-    deriveSharedSecret(publicKeyBase64: string): Promise<this>;
-    encode(data: string): Promise<{
-        text: string;
-        iv: string;
-    }>;
-    decode(encrypted: string, iv: string): Promise<string>;
+    __keyFormat: TKeyFormat;
+    __subtle: SubtleCrypto;
+    constructor(curve?: string, keyFormat?: TKeyFormat);
+    generateKeys(): Promise<this>;
+    exportKey(cryptoKey: CryptoKey, keyFormat?: TKeyFormat): Promise<string>;
+    importKey(keyBase64: string, keyFormat?: TKeyFormat, usages?: KeyUsage[]): Promise<CryptoKey>;
+    setPrivateKey(privateBase64: string): Promise<boolean>;
+    deriveSharedSecret(publicKeyBase64: string, iv: string): Promise<boolean>;
+    encode(data: string): Promise<string>;
+    encodeiv(data: string): Promise<string>;
+    decode(encrypted: string, iv?: string): Promise<string>;
+    decodeiv(encrypted: string): Promise<string>;
 }

package/bin/types/modules/convert/index.d.ts

@@ -1,7 +1,7 @@
 declare const _default: {
     str2Hex: (str: string) => string;
     hex2Str: (hexstr: string) => string;
-    str2ab: (content?: string, base64?: boolean) => ArrayBufferLike;
+    str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
     ab2str: (data: ArrayBuffer, base64?: boolean) => string;
     bytesToStr: (bytes: Uint8Array) => string;
     strToBytes: (str?: string) => Uint8Array;
@@ -11,6 +11,7 @@ declare const _default: {
     textEncode: (text: string) => Uint8Array;
     textDecode: (buf: ArrayBuffer) => string;
     toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+    concatBytes: (...args: Uint8Array[]) => Uint8Array;
     toBase64: (input?: string) => string;
     fromBase64: (input?: string) => string;
     bytesToBase64: (bytes: Uint8Array) => string;

package/bin/types/modules/node/ecdh-web.d.ts

@@ -0,0 +1,4 @@
+import Ecdh, { TKeyFormat } from "../browser/ecdh";
+export default class EcdhWeb extends Ecdh {
+    constructor(curve?: string, keyFormat?: TKeyFormat);
+}

package/bin/types/modules/node/ecdh.d.ts

@@ -4,17 +4,16 @@ export default class Ecdh {
     publicKey: string;
     privateKey: string;
     sharedSecret: string | undefined;
-    iv: string | undefined;
+    iv: string;
     _curve: string;
     _algorithm: string;
     _ecdh: crypto.ECDH | undefined;
     constructor(curve?: string, algorithm?: string);
     generateKey(): void;
-    deriveSharedSecret(otherPublicKey: string, iv: string): this | undefined;
-    encode(data: string): {
-        text: string;
-        authTag: string;
-        iv: string;
-    };
-    decode(encrypted: string, authTag: string, iv: string): string;
+    deriveSharedSecret(otherPublicKey: string, iv: string): boolean;
+    setPrivateKey(privateBase64: string): boolean;
+    encode(data: string): string;
+    encodeiv(data: string): string;
+    decode(encrypted: string, iv?: string): string;
+    decodeiv(encrypted: string): string;
 }

package/bin/types/modules/node/index.d.ts

@@ -1,9 +1,9 @@
 import Ecdh from './ecdh';
-import EcdhSpki from './ecdh-spki';
 import { Socks5 } from './socks5';
+import EcdhWeb from './ecdh-web';
 declare const _default: {
     Ecdh: typeof Ecdh;
-    EcdhSpki: typeof EcdhSpki;
+    EcdhWeb: typeof EcdhWeb;
     Socks5: typeof Socks5;
     getSystemProxy: () => Promise<{
         ipaddress: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddan-js",
-  "version": "2.6.37",
+  "version": "2.6.39",
   "description": "",
   "keywords": [
     "ddan-js",

package/bin/lib/modules/node/ecdh-spki.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const convert_1 = require("../convert");
-const node_crypto_1 = require("node:crypto");
-const subtle = node_crypto_1.default?.webcrypto?.subtle;
-class EcdhSpki {
-    publicKey = '';
-    iv = '';
-    __keyPair;
-    __sharedSecret;
-    __curve;
-    constructor(curve = 'P-256') {
-        this.__curve = curve;
-    }
-    async generateKeys(iv) {
-        const keyPair = await subtle.generateKey({
-            name: 'ECDH',
-            namedCurve: this.__curve, // 使用 P-256 椭圆曲线
-        }, true, // 可以导出
-        ['deriveKey', 'deriveBits']);
-        this.__keyPair = keyPair;
-        this.publicKey = await this.exportSpkiKey(keyPair.publicKey);
-        this.iv = iv;
-        return this;
-    }
-    async exportSpkiKey(cryptoKey) {
-        const exportKey = await subtle.exportKey('spki', // 公钥的格式（适合交换的标准格式）
-        cryptoKey);
-        return convert_1.default.ab2str(exportKey, true);
-    }
-    async importSpkiKey(keyBase64) {
-        const bytes = convert_1.default.base64ToBytes(keyBase64);
-        const publicKey = await subtle.importKey('spki', bytes, {
-            name: 'ECDH',
-            namedCurve: this.__curve,
-        }, true, []);
-        return publicKey;
-    }
-    async deriveSharedSecret(publicKeyBase64) {
-        if (!this.__keyPair)
-            return this;
-        const publicKey = await this.importSpkiKey(publicKeyBase64);
-        const sharedSecret = await subtle.deriveKey({
-            name: 'ECDH',
-            public: publicKey, // 对方的公钥
-        }, this.__keyPair.privateKey, // 自己的私钥
-        { name: 'AES-GCM', length: 256 }, // 派生出的共享密钥用于 AES 加密
-        true, // 可以导出
-        ['encrypt', 'decrypt'] // 用于加密和解密
-        );
-        this.__sharedSecret = sharedSecret;
-        return this;
-    }
-    async encode(data) {
-        if (!this.__sharedSecret || !this.iv)
-            return { text: '', iv: '' };
-        const bytes = convert_1.default.textEncode(data);
-        const encrypted = await subtle.encrypt({
-            name: 'AES-GCM',
-            iv: convert_1.default.base64ToBytes(this.iv),
-        }, this.__sharedSecret, bytes);
-        const b64 = convert_1.default.ab2str(encrypted, true);
-        return { iv: this.iv, text: b64 };
-    }
-    async decode(encrypted, iv) {
-        if (!this.__sharedSecret || !iv)
-            return '';
-        const bytes = convert_1.default.str2ab(encrypted, true);
-        const decrypted = await subtle.decrypt({
-            name: 'AES-GCM',
-            iv: convert_1.default.base64ToBytes(iv),
-        }, this.__sharedSecret, bytes);
-        return convert_1.default.textDecode(decrypted);
-    }
-}
-exports.default = EcdhSpki;

package/bin/types/modules/node/ecdh-spki.d.ts

@@ -1,19 +0,0 @@
-/// <reference types="node" />
-import crypto from "node:crypto";
-export default class EcdhSpki {
-    publicKey: string;
-    iv: string;
-    __keyPair: CryptoKeyPair | undefined;
-    __sharedSecret: CryptoKey | undefined;
-    __curve: string;
-    constructor(curve?: string);
-    generateKeys(iv: string): Promise<this>;
-    exportSpkiKey(cryptoKey: CryptoKey): Promise<string>;
-    importSpkiKey(keyBase64: string): Promise<crypto.webcrypto.CryptoKey>;
-    deriveSharedSecret(publicKeyBase64: string): Promise<this>;
-    encode(data: string): Promise<{
-        text: string;
-        iv: string;
-    }>;
-    decode(encrypted: string, iv: string): Promise<string>;
-}