@totemsdk/core 1.2.5 → 1.2.6

package/dist/wots.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * WOTS Implementation - BouncyCastle Compatible
  *
@@ -13,34 +12,12 @@
  *
  * Source: org.bouncycastle.pqc.crypto.gmss.util.{WinternitzOTSignature, WinternitzOTSVerify, GMSSRandom}
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GMSSRandom = exports.h = exports.u32be = exports.u16be = exports.concatBytes = exports.fromHex = exports.hex = exports.F = void 0;
-exports.setWotsLogger = setWotsLogger;
-exports.disableWotsLogger = disableWotsLogger;
-exports.isWotsDebugEnabled = isWotsDebugEnabled;
-exports.assert32 = assert32;
-exports.getLog = getLog;
-exports.expandPrivateKey = expandPrivateKey;
-exports.toWinternitzDigits = toWinternitzDigits;
-exports.baseWWithChecksum = baseWWithChecksum;
-exports.hashChain = hashChain;
-exports.deriveIndexedSeed = deriveIndexedSeed;
-exports.derivePKdigest = derivePKdigest;
-exports.deriveFullPublicKey = deriveFullPublicKey;
-exports.wotsKeypairFromSeed = wotsKeypairFromSeed;
-exports.wotsSign = wotsSign;
-exports.wotsSignLegacy = wotsSignLegacy;
-exports.wotsPkFromSig = wotsPkFromSig;
-exports.wotsVerify = wotsVerify;
-exports.wotsVerifyDigest = wotsVerifyDigest;
-exports.wotsPublicKeyFromSeed = wotsPublicKeyFromSeed;
-exports.prfChainSeed = prfChainSeed;
-const wasm_sync_js_1 = require("./wasm-sync.js");
-const params_js_1 = require("./params.js");
-const javaStreamables_js_1 = require("./javaStreamables.js");
-const index_js_1 = require("./adapters/index.js");
+import { sha3_256 } from './wasm-sync.js';
+import { getParamSet } from "./params.js";
+import { deriveChainSeedJava } from "./javaStreamables.js";
+import { NoopLogger } from "./adapters/index.js";
 // Module-level debug logger - can be set externally for parity testing
-let wotsLogger = new index_js_1.NoopLogger();
+let wotsLogger = new NoopLogger();
 let wotsDebugEnabled = false;
 /**
  * Enable WOTS debug logging with a custom logger
@@ -50,42 +27,39 @@ let wotsDebugEnabled = false;
  * private key chains and seeds. NEVER enable in production builds.
  * This is intended for development/testing parity verification only.
  */
-function setWotsLogger(logger) {
+export function setWotsLogger(logger) {
     wotsLogger = logger;
     wotsDebugEnabled = true;
 }
 /**
  * Disable WOTS debug logging
  */
-function disableWotsLogger() {
-    wotsLogger = new index_js_1.NoopLogger();
+export function disableWotsLogger() {
+    wotsLogger = new NoopLogger();
     wotsDebugEnabled = false;
 }
 /**
  * Check if WOTS debug logging is enabled
  */
-function isWotsDebugEnabled() {
+export function isWotsDebugEnabled() {
     return wotsDebugEnabled;
 }
 // === Canonical helpers ===
-const F = (x) => (0, wasm_sync_js_1.sha3_256)(x);
-exports.F = F;
-const hex = (u) => {
+export const F = (x) => sha3_256(x);
+export const hex = (u) => {
     let s = '';
     for (let i = 0; i < u.length; i++)
         s += u[i].toString(16).padStart(2, '0');
     return s;
 };
-exports.hex = hex;
-const fromHex = (h) => {
+export const fromHex = (h) => {
     const s = h.replace(/^0x/, '');
     const out = new Uint8Array(s.length >> 1);
     for (let i = 0; i < out.length; i++)
         out[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16);
     return out;
 };
-exports.fromHex = fromHex;
-const concatBytes = (...arrs) => {
+export const concatBytes = (...arrs) => {
     const len = arrs.reduce((n, a) => n + a.length, 0);
     const out = new Uint8Array(len);
     let o = 0;
@@ -95,12 +69,9 @@ const concatBytes = (...arrs) => {
     }
     return out;
 };
-exports.concatBytes = concatBytes;
-const u16be = (n) => new Uint8Array([(n >>> 8) & 0xff, n & 0xff]);
-exports.u16be = u16be;
-const u32be = (n) => new Uint8Array([(n >>> 24) & 255, (n >>> 16) & 255, (n >>> 8) & 255, n & 255]);
-exports.u32be = u32be;
-function assert32(u, label = 'value') {
+export const u16be = (n) => new Uint8Array([(n >>> 8) & 0xff, n & 0xff]);
+export const u32be = (n) => new Uint8Array([(n >>> 24) & 255, (n >>> 16) & 255, (n >>> 8) & 255, n & 255]);
+export function assert32(u, label = 'value') {
     if (!(u instanceof Uint8Array))
         throw new Error(`${label} must be a Uint8Array`);
     if (u.length !== 32)
@@ -108,9 +79,9 @@ function assert32(u, label = 'value') {
 }
 // Legacy aliases
 const u8 = (len) => new Uint8Array(len);
-exports.h = exports.F;
-const concat = exports.concatBytes;
-const defaultParamSet = (0, params_js_1.getParamSet)();
+export const h = F;
+const concat = concatBytes;
+const defaultParamSet = getParamSet();
 /**
  * GMSSRandom - BouncyCastle's stateful PRNG for WOTS chain seed derivation
  *
@@ -121,7 +92,7 @@ const defaultParamSet = (0, params_js_1.getParamSet)();
  *
  * The state is MUTATED in place after each call.
  */
-class GMSSRandom {
+export class GMSSRandom {
     /**
      * Generate next random value and update state
      *
@@ -131,7 +102,7 @@ class GMSSRandom {
     static nextSeed(state) {
         assert32(state, 'state');
         // rand = H(state)
-        const rand = (0, exports.F)(state);
+        const rand = F(state);
         // state = state + rand (byte-wise addition with carry, little-endian)
         GMSSRandom.addByteArrays(state, rand);
         // state = state + 1
@@ -165,7 +136,6 @@ class GMSSRandom {
         }
     }
 }
-exports.GMSSRandom = GMSSRandom;
 /**
  * getLog - Calculate ceil(log2(x))
  *
@@ -175,7 +145,7 @@ exports.GMSSRandom = GMSSRandom;
  *   while (i < intValue) { i <<= 1; log++; }
  *   return log;
  */
-function getLog(intValue) {
+export function getLog(intValue) {
     let log = 1;
     let i = 2;
     while (i < intValue) {
@@ -194,13 +164,13 @@ function getLog(intValue) {
  *     privateKeyOTS[i] = gmssRandom.nextSeed(dummy);
  *   }
  */
-function expandPrivateKey(seed, ps = (0, params_js_1.getParamSet)()) {
+export function expandPrivateKey(seed, ps = getParamSet()) {
     assert32(seed, 'seed');
     // Copy seed to mutable state
     const state = new Uint8Array(seed);
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[expandPrivateKey] Input seed: ${(0, exports.hex)(seed).substring(0, 64)}...`);
-        wotsLogger.debug(`[expandPrivateKey] Initial state: ${(0, exports.hex)(state).substring(0, 64)}...`);
+        wotsLogger.debug(`[expandPrivateKey] Input seed: ${hex(seed).substring(0, 64)}...`);
+        wotsLogger.debug(`[expandPrivateKey] Initial state: ${hex(state).substring(0, 64)}...`);
     }
     // Generate L chain seeds using stateful PRNG
     const privateKeys = [];
@@ -209,13 +179,13 @@ function expandPrivateKey(seed, ps = (0, params_js_1.getParamSet)()) {
         privateKeys.push(pk);
         // Log first few private keys for debugging
         if (wotsDebugEnabled && i < 3) {
-            wotsLogger.debug(`[expandPrivateKey] pk[${i}]: ${(0, exports.hex)(pk)}`);
-            wotsLogger.debug(`[expandPrivateKey] state after pk[${i}]: ${(0, exports.hex)(state).substring(0, 32)}...`);
+            wotsLogger.debug(`[expandPrivateKey] pk[${i}]: ${hex(pk)}`);
+            wotsLogger.debug(`[expandPrivateKey] state after pk[${i}]: ${hex(state).substring(0, 32)}...`);
         }
     }
     if (wotsDebugEnabled) {
         wotsLogger.debug(`[expandPrivateKey] Generated ${privateKeys.length} private keys`);
-        wotsLogger.debug(`[expandPrivateKey] pk[33] (last): ${(0, exports.hex)(privateKeys[33])}`);
+        wotsLogger.debug(`[expandPrivateKey] pk[33] (last): ${hex(privateKeys[33])}`);
     }
     return privateKeys;
 }
@@ -230,7 +200,7 @@ function expandPrivateKey(seed, ps = (0, params_js_1.getParamSet)()) {
  *
  * Matches WinternitzOTSignature.getSignature() for w=8 case
  */
-function toWinternitzDigits(hash32, ps = (0, params_js_1.getParamSet)()) {
+export function toWinternitzDigits(hash32, ps = getParamSet()) {
     assert32(hash32, 'hash');
     if (ps.w !== 8) {
         throw new Error(`Only w=8 is supported. Got w=${ps.w}`);
@@ -258,7 +228,7 @@ function toWinternitzDigits(hash32, ps = (0, params_js_1.getParamSet)()) {
         c >>>= ps.w;
     }
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[toWinternitzDigits] Input hash: ${(0, exports.hex)(hash32)}`);
+        wotsLogger.debug(`[toWinternitzDigits] Input hash: ${hex(hash32)}`);
         wotsLogger.debug(`[toWinternitzDigits] First 5 message digits: [${digits.slice(0, 5).join(', ')}]`);
         wotsLogger.debug(`[toWinternitzDigits] Last 5 message digits: [${digits.slice(-5).join(', ')}]`);
         wotsLogger.debug(`[toWinternitzDigits] Digit sum: ${digitSum}`);
@@ -276,7 +246,7 @@ function toWinternitzDigits(hash32, ps = (0, params_js_1.getParamSet)()) {
  * Decompose digest into base-w digits + checksum
  * Returns flat array of all L digits
  */
-function baseWWithChecksum(msgHash, paramSet) {
+export function baseWWithChecksum(msgHash, paramSet) {
     const ps = paramSet || defaultParamSet;
     const { digits, checksumDigits } = toWinternitzDigits(msgHash, ps);
     const result = digits.concat(checksumDigits);
@@ -292,13 +262,13 @@ function baseWWithChecksum(msgHash, paramSet) {
  * - If rounds < 1: return input unchanged
  * - Otherwise: hash `rounds` times
  */
-function hashChain(x, rounds) {
+export function hashChain(x, rounds) {
     if (rounds < 1) {
         return new Uint8Array(x);
     }
-    let result = (0, exports.F)(x);
+    let result = F(x);
     for (let i = 1; i < rounds; i++) {
-        result = (0, exports.F)(result);
+        result = F(result);
     }
     return result;
 }
@@ -314,12 +284,12 @@ function hashChain(x, rounds) {
  * This old implementation used H(seed || u32be(i)) which is NOT Java compatible.
  * @deprecated Use deriveChainSeedJava from javaStreamables.ts
  */
-function deriveIndexedSeed(seed, keyIndex) {
+export function deriveIndexedSeed(seed, keyIndex) {
     assert32(seed, 'seed');
     // Use Java-compatible derivation: hashAllObjects(MiniNumber(i), MiniData(seed))
-    const result = (0, javaStreamables_js_1.deriveChainSeedJava)(seed, keyIndex);
+    const result = deriveChainSeedJava(seed, keyIndex);
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[deriveIndexedSeed] seed=${(0, exports.hex)(seed).substring(0, 32)}..., keyIndex=${keyIndex} => ${(0, exports.hex)(result)}`);
+        wotsLogger.debug(`[deriveIndexedSeed] seed=${hex(seed).substring(0, 32)}..., keyIndex=${keyIndex} => ${hex(result)}`);
     }
     return result;
 }
@@ -336,7 +306,7 @@ function deriveIndexedSeed(seed, keyIndex) {
  *   }
  *   return H(buf);
  */
-function derivePKdigest(seed, i, ps = (0, params_js_1.getParamSet)()) {
+export function derivePKdigest(seed, i, ps = getParamSet()) {
     assert32(seed, 'seed');
     // Derive unique seed for this key index
     const indexedSeed = deriveIndexedSeed(seed, i);
@@ -350,7 +320,7 @@ function derivePKdigest(seed, i, ps = (0, params_js_1.getParamSet)()) {
         buf.set(top, j * 32);
     }
     // Return H(all chain tops)
-    return (0, exports.F)(buf);
+    return F(buf);
 }
 /**
  * Derive full WOTS public key (L × 32 bytes) without final hash
@@ -358,16 +328,16 @@ function derivePKdigest(seed, i, ps = (0, params_js_1.getParamSet)()) {
  * Returns the concatenation of all chain tops BEFORE hashing.
  * Required by Minima's SignatureProof which expects the full public key.
  */
-function deriveFullPublicKey(seed, i, ps = (0, params_js_1.getParamSet)()) {
+export function deriveFullPublicKey(seed, i, ps = getParamSet()) {
     assert32(seed, 'seed');
     if (wotsDebugEnabled) {
         wotsLogger.debug(`[deriveFullPublicKey] ========== PK DERIVATION START ==========`);
-        wotsLogger.debug(`[deriveFullPublicKey] Master seed: ${(0, exports.hex)(seed).substring(0, 32)}..., keyIndex: ${i}`);
+        wotsLogger.debug(`[deriveFullPublicKey] Master seed: ${hex(seed).substring(0, 32)}..., keyIndex: ${i}`);
     }
     // Derive unique seed for this key index
     const indexedSeed = deriveIndexedSeed(seed, i);
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[deriveFullPublicKey] Indexed seed: ${(0, exports.hex)(indexedSeed)}`);
+        wotsLogger.debug(`[deriveFullPublicKey] Indexed seed: ${hex(indexedSeed)}`);
     }
     const privateKeys = expandPrivateKey(indexedSeed, ps);
     const rounds = ps.maxDigit; // 255
@@ -377,16 +347,16 @@ function deriveFullPublicKey(seed, i, ps = (0, params_js_1.getParamSet)()) {
         buf.set(top, j * 32);
         // Log first few chain tops for debugging
         if (wotsDebugEnabled && j < 3) {
-            wotsLogger.debug(`[deriveFullPublicKey] chain[${j}]: pk=${(0, exports.hex)(privateKeys[j]).substring(0, 16)}... rounds=${rounds} => top=${(0, exports.hex)(top).substring(0, 16)}...`);
+            wotsLogger.debug(`[deriveFullPublicKey] chain[${j}]: pk=${hex(privateKeys[j]).substring(0, 16)}... rounds=${rounds} => top=${hex(top).substring(0, 16)}...`);
         }
     }
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[deriveFullPublicKey] Full public key (${buf.length}B): ${(0, exports.hex)(buf).substring(0, 64)}...${(0, exports.hex)(buf).substring((0, exports.hex)(buf).length - 32)}`);
+        wotsLogger.debug(`[deriveFullPublicKey] Full public key (${buf.length}B): ${hex(buf).substring(0, 64)}...${hex(buf).substring(hex(buf).length - 32)}`);
         wotsLogger.debug(`[deriveFullPublicKey] ========== PK DERIVATION END ==========`);
     }
     return buf; // L * 32 = 1088 bytes
 }
-function wotsKeypairFromSeed(seed, index, paramSet) {
+export function wotsKeypairFromSeed(seed, index, paramSet) {
     assert32(seed, 'seed');
     const ps = paramSet || defaultParamSet;
     const pkDigest = derivePKdigest(seed, index, ps);
@@ -408,25 +378,25 @@ function wotsKeypairFromSeed(seed, index, paramSet) {
  * @param ps - WOTS parameter set (default: minima)
  * @returns Flat signature (L × 32 = 1088 bytes)
  */
-function wotsSign(seed, i, message, ps = (0, params_js_1.getParamSet)()) {
+export function wotsSign(seed, i, message, ps = getParamSet()) {
     assert32(seed, 'seed');
     assert32(message, 'message');
     if (wotsDebugEnabled) {
         wotsLogger.debug(`[wotsSign] ========== WOTS SIGN START ==========`);
-        wotsLogger.debug(`[wotsSign] Master seed: ${(0, exports.hex)(seed)}`);
+        wotsLogger.debug(`[wotsSign] Master seed: ${hex(seed)}`);
         wotsLogger.debug(`[wotsSign] Key index: ${i}`);
-        wotsLogger.debug(`[wotsSign] Message (raw): ${(0, exports.hex)(message)}`);
+        wotsLogger.debug(`[wotsSign] Message (raw): ${hex(message)}`);
     }
     // Derive unique seed for this key index
     const indexedSeed = deriveIndexedSeed(seed, i);
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[wotsSign] Indexed seed (after deriveIndexedSeed): ${(0, exports.hex)(indexedSeed)}`);
+        wotsLogger.debug(`[wotsSign] Indexed seed (after deriveIndexedSeed): ${hex(indexedSeed)}`);
     }
     const privateKeys = expandPrivateKey(indexedSeed, ps);
     // CRITICAL: Hash the message internally to match Java/BouncyCastle Winternitz behavior
     // Java's WinternitzOTSignature.getSignature() always hashes the message first
     // Callers pass RAW 32-byte data (tx digest, child root), NOT pre-hashed!
-    const hashedMsg = (0, exports.F)(message);
+    const hashedMsg = F(message);
     const { digits, checksumDigits } = toWinternitzDigits(hashedMsg, ps);
     const allDigits = digits.concat(checksumDigits);
     if (allDigits.length !== ps.L) {
@@ -442,11 +412,11 @@ function wotsSign(seed, i, message, ps = (0, params_js_1.getParamSet)()) {
         out.set(sigPart, j * 32);
         // Log first few and last signature chains for debugging
         if (wotsDebugEnabled && (j < 3 || j >= ps.L - 2)) {
-            wotsLogger.debug(`[wotsSign] chain[${j}]: pk=${(0, exports.hex)(privateKeys[j]).substring(0, 16)}... rounds=${rounds} => sig=${(0, exports.hex)(sigPart).substring(0, 16)}...`);
+            wotsLogger.debug(`[wotsSign] chain[${j}]: pk=${hex(privateKeys[j]).substring(0, 16)}... rounds=${rounds} => sig=${hex(sigPart).substring(0, 16)}...`);
         }
     }
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[wotsSign] Signature output (${out.length} bytes): ${(0, exports.hex)(out).substring(0, 64)}...${(0, exports.hex)(out).substring((0, exports.hex)(out).length - 64)}`);
+        wotsLogger.debug(`[wotsSign] Signature output (${out.length} bytes): ${hex(out).substring(0, 64)}...${hex(out).substring(hex(out).length - 64)}`);
         wotsLogger.debug(`[wotsSign] ========== WOTS SIGN END ==========`);
     }
     return out;
@@ -454,8 +424,8 @@ function wotsSign(seed, i, message, ps = (0, params_js_1.getParamSet)()) {
 /**
  * Legacy wrapper returning structured signature
  */
-function wotsSignLegacy(msgHash, seed, index, paramSet) {
-    const ps = paramSet || (0, params_js_1.getParamSet)();
+export function wotsSignLegacy(msgHash, seed, index, paramSet) {
+    const ps = paramSet || getParamSet();
     const sig = wotsSign(seed, index, msgHash, ps);
     const chunks = [];
     for (let i = 0; i < ps.L; i++) {
@@ -475,10 +445,10 @@ function wotsSignLegacy(msgHash, seed, index, paramSet) {
  * CRITICAL: This function hashes the message internally to match Java/BouncyCastle
  * Winternitz behavior. Both wotsSign and wotsPkFromSig hash internally for parity.
  */
-function wotsPkFromSig(message, signature, paramSet) {
+export function wotsPkFromSig(message, signature, paramSet) {
     const ps = paramSet || defaultParamSet;
     // CRITICAL: Hash the message internally to match Java/BouncyCastle Winternitz behavior
-    const hashedMsg = (0, exports.F)(message);
+    const hashedMsg = F(message);
     const allDigits = baseWWithChecksum(hashedMsg, ps);
     if (signature.sig.length !== ps.L) {
         throw new Error(`Wrong signature length: expected ${ps.L}, got ${signature.sig.length}`);
@@ -489,7 +459,7 @@ function wotsPkFromSig(message, signature, paramSet) {
         const top = hashChain(signature.sig[i], stepsUp);
         buf.set(top, i * 32);
     }
-    return (0, exports.F)(buf);
+    return F(buf);
 }
 /**
  * Verify WOTS signature against a FULL 1088-byte public key
@@ -510,7 +480,7 @@ function wotsPkFromSig(message, signature, paramSet) {
  * @param pkFull - The FULL 1088-byte WOTS public key (L=34 × 32 bytes)
  * @param ps - WOTS parameter set (default: minima)
  */
-function wotsVerify(sig, message, pkFull, ps = (0, params_js_1.getParamSet)()) {
+export function wotsVerify(sig, message, pkFull, ps = getParamSet()) {
     // CRITICAL: Java verifies against FULL 1088-byte public key, not 32-byte digest
     const expectedLen = ps.L * 32;
     if (pkFull.length !== expectedLen) {
@@ -520,7 +490,7 @@ function wotsVerify(sig, message, pkFull, ps = (0, params_js_1.getParamSet)()) {
         return false;
     }
     // CRITICAL: Hash the message internally to match Java/BouncyCastle Winternitz behavior
-    const hashedMsg = (0, exports.F)(message);
+    const hashedMsg = F(message);
     const allDigits = baseWWithChecksum(hashedMsg, ps);
     const buf = new Uint8Array(expectedLen);
     for (let j = 0; j < ps.L; j++) {
@@ -542,13 +512,13 @@ function wotsVerify(sig, message, pkFull, ps = (0, params_js_1.getParamSet)()) {
  * Legacy verify function that accepts a 32-byte digest
  * @deprecated Use wotsVerify with full 1088-byte public key instead
  */
-function wotsVerifyDigest(sig, message, pkDigest, ps = (0, params_js_1.getParamSet)()) {
+export function wotsVerifyDigest(sig, message, pkDigest, ps = getParamSet()) {
     assert32(pkDigest, 'pkDigest');
     const expectedLen = ps.L * 32;
     if (sig.length !== expectedLen) {
         return false;
     }
-    const msgHash = (0, exports.F)(message);
+    const msgHash = F(message);
     const allDigits = baseWWithChecksum(msgHash, ps);
     const buf = new Uint8Array(expectedLen);
     for (let j = 0; j < ps.L; j++) {
@@ -557,7 +527,7 @@ function wotsVerifyDigest(sig, message, pkDigest, ps = (0, params_js_1.getParamS
         const top = hashChain(sigPart, stepsUp);
         buf.set(top, j * 32);
     }
-    const recomputed = (0, exports.F)(buf);
+    const recomputed = F(buf);
     if (recomputed.length !== pkDigest.length)
         return false;
     let diff = 0;
@@ -568,7 +538,7 @@ function wotsVerifyDigest(sig, message, pkDigest, ps = (0, params_js_1.getParamS
 /**
  * Generate WOTS public key from seed (convenience wrapper)
  */
-function wotsPublicKeyFromSeed(seed, index = 0, paramSet) {
+export function wotsPublicKeyFromSeed(seed, index = 0, paramSet) {
     assert32(seed, 'seed');
     const keypair = wotsKeypairFromSeed(seed, index, paramSet);
     return keypair.pk;
@@ -578,7 +548,7 @@ function wotsPublicKeyFromSeed(seed, index = 0, paramSet) {
 /**
  * @deprecated Use expandPrivateKey instead
  */
-function prfChainSeed(seed, i, j, _paramSet) {
+export function prfChainSeed(seed, i, j, _paramSet) {
     // This function no longer makes sense with stateful PRNG
     // For compatibility, derive the j-th chain seed for key i
     const privateKeys = expandPrivateKey(seed, _paramSet);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/core",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "Core cryptographic primitives for Totem SDK — backed by Rust/WASM",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",