@ckb-ccc/core 0.1.0-alpha.7 → 0.1.1

package/dist.commonjs/hasher/hasherCkb.js

@@ -1,26 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HasherCkb = void 0;
-exports.hashCkb = hashCkb;
-exports.hashTypeId = hashTypeId;
-const blake2b_1 = require("@noble/hashes/blake2b");
-const index_js_1 = require("../bytes/index.js");
-const index_js_2 = require("../ckb/index.js");
-const index_js_3 = require("../hex/index.js");
-const index_js_4 = require("../num/index.js");
-const advanced_js_1 = require("./advanced.js");
+import { blake2b } from "@noble/hashes/blake2b";
+import { bytesFrom } from "../bytes/index.js";
+import { CellInput } from "../ckb/index.js";
+import { hexFrom } from "../hex/index.js";
+import { numLeToBytes } from "../num/index.js";
+import { CKB_BLAKE2B_PERSONAL } from "./advanced.js";
 /**
  * @public
  */
-class HasherCkb {
+export class HasherCkb {
     /**
      * Creates an instance of Hasher.
      *
      * @param outLength - The output length of the hash in bytes. Default is 32.
      * @param personal - The personal string for the Blake2b algorithm. Default is CKB_BLAKE2B_PERSONAL.
      */
-    constructor(outLength = 32, personal = advanced_js_1.CKB_BLAKE2B_PERSONAL) {
-        this.hasher = blake2b_1.blake2b.create({
+    constructor(outLength = 32, personal = CKB_BLAKE2B_PERSONAL) {
+        this.hasher = blake2b.create({
             personalization: personal,
             dkLen: outLength,
         });
@@ -39,7 +34,7 @@ class HasherCkb {
      * ```
      */
     update(data) {
-        this.hasher.update((0, index_js_1.bytesFrom)(data));
+        this.hasher.update(bytesFrom(data));
         return this;
     }
     /**
@@ -55,10 +50,9 @@ class HasherCkb {
      * ```
      */
     digest() {
-        return (0, index_js_3.hexFrom)(this.hasher.digest());
+        return hexFrom(this.hasher.digest());
     }
 }
-exports.HasherCkb = HasherCkb;
 /**
  * Computes the CKB hash of the given data using the Blake2b algorithm.
  * @public
@@ -71,7 +65,7 @@ exports.HasherCkb = HasherCkb;
  * const hash = hashCkb("some data"); // Outputs something like "0x..."
  * ```
  */
-function hashCkb(...data) {
+export function hashCkb(...data) {
     const hasher = new HasherCkb();
     data.forEach((d) => hasher.update(d));
     return hasher.digest();
@@ -89,6 +83,6 @@ function hashCkb(...data) {
  * const hash = hashTypeId(cellInput, outputIndex); // Outputs something like "0x..."
  * ```
  */
-function hashTypeId(cellInputLike, outputIndex) {
-    return hashCkb(index_js_2.CellInput.from(cellInputLike).toBytes(), (0, index_js_4.numLeToBytes)(outputIndex, 8));
+export function hashTypeId(cellInputLike, outputIndex) {
+    return hashCkb(CellInput.from(cellInputLike).toBytes(), numLeToBytes(outputIndex, 8));
 }

package/dist.commonjs/hasher/hasherKeecak256.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HasherKeecak256 = void 0;
-const sha3_1 = require("@noble/hashes/sha3");
-const index_js_1 = require("../bytes/index.js");
-const index_js_2 = require("../hex/index.js");
+import { keccak_256 } from "@noble/hashes/sha3";
+import { bytesFrom } from "../bytes/index.js";
+import { hexFrom } from "../hex/index.js";
 /**
  * @public
  */
-class HasherKeecak256 {
+export class HasherKeecak256 {
     /**
      * Creates an instance of Hasher.
      */
     constructor() {
-        this.hasher = sha3_1.keccak_256.create();
+        this.hasher = keccak_256.create();
     }
     /**
      * Updates the hash with the given data.
@@ -28,7 +25,7 @@ class HasherKeecak256 {
      * ```
      */
     update(data) {
-        this.hasher.update((0, index_js_1.bytesFrom)(data));
+        this.hasher.update(bytesFrom(data));
         return this;
     }
     /**
@@ -44,7 +41,6 @@ class HasherKeecak256 {
      * ```
      */
     digest() {
-        return (0, index_js_2.hexFrom)(this.hasher.digest());
+        return hexFrom(this.hasher.digest());
     }
 }
-exports.HasherKeecak256 = HasherKeecak256;

package/dist.commonjs/hasher/index.js

@@ -1,19 +1,3 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./hasher.js"), exports);
-__exportStar(require("./hasherCkb.js"), exports);
-__exportStar(require("./hasherKeecak256.js"), exports);
+export * from "./hasher.js";
+export * from "./hasherCkb.js";
+export * from "./hasherKeecak256.js";

package/dist.commonjs/hex/index.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hexFrom = hexFrom;
-const index_js_1 = require("../bytes/index.js");
+import { bytesFrom, bytesTo } from "../bytes/index.js";
 /**
  * Converts a HexLike value to a Hex string.
  * @public
@@ -15,6 +12,6 @@ const index_js_1 = require("../bytes/index.js");
  * const hexStringFromBytes = hexFrom(new Uint8Array([104, 101, 108, 108, 111])); // Outputs "0x68656c6c6f"
  * ```
  */
-function hexFrom(hex) {
-    return `0x${(0, index_js_1.bytesTo)((0, index_js_1.bytesFrom)(hex), "hex")}`;
+export function hexFrom(hex) {
+    return `0x${bytesTo(bytesFrom(hex), "hex")}`;
 }

package/dist.commonjs/index.js

@@ -1,31 +1,2 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ccc = void 0;
-__exportStar(require("./barrel.js"), exports);
-exports.ccc = __importStar(require("./barrel.js"));
+export * from "./barrel.js";
+export * as ccc from "./barrel.js";

package/dist.commonjs/keystore/index.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.keystoreEncrypt = keystoreEncrypt;
-exports.keystoreDecrypt = keystoreDecrypt;
-const aes_1 = require("@noble/ciphers/aes");
-const scrypt_1 = require("@noble/hashes/scrypt");
-const sha3_1 = require("@noble/hashes/sha3");
-const utils_1 = require("@noble/hashes/utils");
-const index_js_1 = require("../bytes/index.js");
-const index_js_2 = require("../hex/index.js");
+import { ctr } from "@noble/ciphers/aes";
+import { scryptAsync } from "@noble/hashes/scrypt";
+import { keccak_256 } from "@noble/hashes/sha3";
+import { randomBytes } from "@noble/hashes/utils";
+import { bytesConcat, bytesFrom } from "../bytes/index.js";
+import { hexFrom } from "../hex/index.js";
 // The parameter r ("blockSize")
 const DEFAULT_SCRYPT_PARAM_R = 8;
 // The parallelization parameter p
@@ -15,35 +11,35 @@ const DEFAULT_SCRYPT_PARAM_P = 1;
 // The CPU/Memory cost parameter N
 const DEFAULT_SCRYPT_PARAM_N = 262144;
 function mac(derivedKey, cipherText) {
-    return (0, index_js_2.hexFrom)((0, sha3_1.keccak_256)((0, index_js_1.bytesConcat)(derivedKey.slice(16, 32), cipherText))).slice(2);
+    return hexFrom(keccak_256(bytesConcat(derivedKey.slice(16, 32), cipherText))).slice(2);
 }
 /**
  * @public
  */
-async function keystoreEncrypt(privateKeyLike, chainCodeLike, password) {
-    const salt = (0, utils_1.randomBytes)(32);
-    const iv = (0, utils_1.randomBytes)(16);
+export async function keystoreEncrypt(privateKeyLike, chainCodeLike, password) {
+    const salt = randomBytes(32);
+    const iv = randomBytes(16);
     const kdfparams = {
         dklen: 32,
-        salt: (0, index_js_2.hexFrom)(salt).slice(2),
+        salt: hexFrom(salt).slice(2),
         n: DEFAULT_SCRYPT_PARAM_N,
         r: DEFAULT_SCRYPT_PARAM_R,
         p: DEFAULT_SCRYPT_PARAM_P,
     };
-    const derivedKey = await (0, scrypt_1.scryptAsync)((0, index_js_1.bytesFrom)(password, "utf8"), salt, {
+    const derivedKey = await scryptAsync(bytesFrom(password, "utf8"), salt, {
         N: kdfparams.n,
         r: kdfparams.r,
         p: kdfparams.p,
         dkLen: kdfparams.dklen,
     });
-    const cipher = (0, aes_1.ctr)(derivedKey.slice(0, 16), iv.map((v) => v));
-    const ciphertext = cipher.encrypt((0, index_js_1.bytesConcat)((0, index_js_1.bytesFrom)(privateKeyLike), (0, index_js_1.bytesFrom)(chainCodeLike)));
+    const cipher = ctr(derivedKey.slice(0, 16), iv.map((v) => v));
+    const ciphertext = cipher.encrypt(bytesConcat(bytesFrom(privateKeyLike), bytesFrom(chainCodeLike)));
     return {
-        id: (0, index_js_2.hexFrom)((0, utils_1.randomBytes)(16)).slice(2),
+        id: hexFrom(randomBytes(16)).slice(2),
         crypto: {
-            ciphertext: (0, index_js_2.hexFrom)(ciphertext).slice(2),
+            ciphertext: hexFrom(ciphertext).slice(2),
             cipherparams: {
-                iv: (0, index_js_2.hexFrom)(iv).slice(2),
+                iv: hexFrom(iv).slice(2),
             },
             cipher: "aes-128-ctr",
             kdf: "scrypt",
@@ -55,7 +51,7 @@ async function keystoreEncrypt(privateKeyLike, chainCodeLike, password) {
 /**
  * @public
  */
-async function keystoreDecrypt(keystore, password) {
+export async function keystoreDecrypt(keystore, password) {
     if (typeof keystore !== "object" ||
         keystore === null ||
         !("crypto" in keystore)) {
@@ -91,17 +87,17 @@ async function keystoreDecrypt(keystore, password) {
         typeof kdfparams.salt !== "string") {
         throw Error("Invalid kdfparams");
     }
-    const derivedKey = await (0, scrypt_1.scryptAsync)((0, index_js_1.bytesFrom)(password, "utf8"), (0, index_js_1.bytesFrom)(kdfparams.salt), {
+    const derivedKey = await scryptAsync(bytesFrom(password, "utf8"), bytesFrom(kdfparams.salt), {
         N: kdfparams.n,
         r: kdfparams.r,
         p: kdfparams.p,
         dkLen: kdfparams.dklen,
     });
-    const ciphertext = (0, index_js_1.bytesFrom)(crypto.ciphertext);
+    const ciphertext = bytesFrom(crypto.ciphertext);
     if (mac(derivedKey, ciphertext) !== crypto.mac) {
         throw Error("Invalid password");
     }
-    const cipher = (0, aes_1.ctr)(derivedKey.slice(0, 16), (0, index_js_1.bytesFrom)(crypto.cipherparams.iv));
+    const cipher = ctr(derivedKey.slice(0, 16), bytesFrom(crypto.cipherparams.iv));
     const result = cipher.decrypt(ciphertext);
     return {
         privateKey: result.slice(0, 32),

package/dist.commonjs/molecule/codec.js

@@ -1,21 +1,7 @@
-"use strict";
 /* eslint-disable @typescript-eslint/no-explicit-any */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Codec = void 0;
-exports.fixedItemVec = fixedItemVec;
-exports.dynItemVec = dynItemVec;
-exports.vector = vector;
-exports.option = option;
-exports.byteVec = byteVec;
-exports.table = table;
-exports.union = union;
-exports.struct = struct;
-exports.array = array;
-exports.uint = uint;
-exports.uintNumber = uintNumber;
-const index_js_1 = require("../bytes/index.js");
-const index_js_2 = require("../num/index.js");
-class Codec {
+import { bytesConcat, bytesFrom } from "../bytes/index.js";
+import { numBeFromBytes, numBeToBytes, numFromBytes, numToBytes, } from "../num/index.js";
+export class Codec {
     constructor(encode, decode, byteLength) {
         this.encode = encode;
         this.decode = decode;
@@ -34,18 +20,17 @@ class Codec {
         });
     }
 }
-exports.Codec = Codec;
 function uint32To(numLike) {
-    return (0, index_js_2.numToBytes)(numLike, 4);
+    return numToBytes(numLike, 4);
 }
 function uint32From(bytesLike) {
-    return Number((0, index_js_2.numFromBytes)(bytesLike));
+    return Number(numFromBytes(bytesLike));
 }
 /**
  * Vector with fixed size item codec
  * @param itemCodec fixed-size vector item codec
  */
-function fixedItemVec(itemCodec) {
+export function fixedItemVec(itemCodec) {
     const itemByteLength = itemCodec.byteLength;
     if (itemByteLength === undefined) {
         throw new Error("fixedItemVec: itemCodec requires a byte length");
@@ -53,14 +38,14 @@ function fixedItemVec(itemCodec) {
     return Codec.from({
         encode(userDefinedItems) {
             try {
-                return userDefinedItems.reduce((concatted, item) => (0, index_js_1.bytesConcat)(concatted, itemCodec.encode(item)), uint32To(userDefinedItems.length));
+                return userDefinedItems.reduce((concatted, item) => bytesConcat(concatted, itemCodec.encode(item)), uint32To(userDefinedItems.length));
             }
             catch (e) {
                 throw new Error(`fixedItemVec(${e?.toString()})`);
             }
         },
         decode(buffer) {
-            const value = (0, index_js_1.bytesFrom)(buffer);
+            const value = bytesFrom(buffer);
             if (value.byteLength < 4) {
                 throw new Error(`fixedItemVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`);
             }
@@ -86,7 +71,7 @@ function fixedItemVec(itemCodec) {
  * Vector with dynamic size item codec, you can create a recursive vector with this function
  * @param itemCodec the vector item codec. It can be fixed-size or dynamic-size.
  */
-function dynItemVec(itemCodec) {
+export function dynItemVec(itemCodec) {
     return Codec.from({
         encode(userDefinedItems) {
             try {
@@ -94,24 +79,24 @@ function dynItemVec(itemCodec) {
                     const encodedItem = itemCodec.encode(item);
                     const packedHeader = uint32To(offset);
                     return {
-                        header: (0, index_js_1.bytesConcat)(header, packedHeader),
-                        body: (0, index_js_1.bytesConcat)(body, encodedItem),
-                        offset: offset + (0, index_js_1.bytesFrom)(encodedItem).byteLength,
+                        header: bytesConcat(header, packedHeader),
+                        body: bytesConcat(body, encodedItem),
+                        offset: offset + bytesFrom(encodedItem).byteLength,
                     };
                 }, {
-                    header: (0, index_js_1.bytesFrom)([]),
-                    body: (0, index_js_1.bytesFrom)([]),
+                    header: bytesFrom([]),
+                    body: bytesFrom([]),
                     offset: 4 + userDefinedItems.length * 4,
                 });
                 const packedTotalSize = uint32To(encoded.header.byteLength + encoded.body.byteLength + 4);
-                return (0, index_js_1.bytesConcat)(packedTotalSize, encoded.header, encoded.body);
+                return bytesConcat(packedTotalSize, encoded.header, encoded.body);
             }
             catch (e) {
                 throw new Error(`dynItemVec(${e?.toString()})`);
             }
         },
         decode(buffer) {
-            const value = (0, index_js_1.bytesFrom)(buffer);
+            const value = bytesFrom(buffer);
             const byteLength = uint32From(value.slice(0, 4));
             if (byteLength !== value.byteLength) {
                 throw new Error(`dynItemVec: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`);
@@ -143,7 +128,7 @@ function dynItemVec(itemCodec) {
  * General vector codec, if `itemCodec` is fixed size type, it will create a fixvec codec, otherwise a dynvec codec will be created.
  * @param itemCodec
  */
-function vector(itemCodec) {
+export function vector(itemCodec) {
     if (itemCodec.byteLength !== undefined) {
         return fixedItemVec(itemCodec);
     }
@@ -156,11 +141,11 @@ function vector(itemCodec) {
  * - if it's not empty, just serialize the inner item (the size is same as the inner item's size).
  * @param innerCodec
  */
-function option(innerCodec) {
+export function option(innerCodec) {
     return Codec.from({
         encode(userDefinedOrNull) {
             if (!userDefinedOrNull) {
-                return (0, index_js_1.bytesFrom)([]);
+                return bytesFrom([]);
             }
             try {
                 return innerCodec.encode(userDefinedOrNull);
@@ -170,7 +155,7 @@ function option(innerCodec) {
             }
         },
         decode(buffer) {
-            const value = (0, index_js_1.bytesFrom)(buffer);
+            const value = bytesFrom(buffer);
             if (value.byteLength === 0) {
                 return undefined;
             }
@@ -187,20 +172,20 @@ function option(innerCodec) {
  * Wrap the encoded value with a fixed-length buffer
  * @param codec
  */
-function byteVec(codec) {
+export function byteVec(codec) {
     return Codec.from({
         encode(userDefined) {
             try {
-                const payload = (0, index_js_1.bytesFrom)(codec.encode(userDefined));
+                const payload = bytesFrom(codec.encode(userDefined));
                 const byteLength = uint32To(payload.byteLength);
-                return (0, index_js_1.bytesConcat)(byteLength, payload);
+                return bytesConcat(byteLength, payload);
             }
             catch (e) {
                 throw new Error(`byteVec(${e?.toString()})`);
             }
         },
         decode(buffer) {
-            const value = (0, index_js_1.bytesFrom)(buffer);
+            const value = bytesFrom(buffer);
             if (value.byteLength < 4) {
                 throw new Error(`byteVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`);
             }
@@ -221,7 +206,7 @@ function byteVec(codec) {
  * Table is a dynamic-size type. It can be considered as a dynvec but the length is fixed.
  * @param codecLayout
  */
-function table(codecLayout) {
+export function table(codecLayout) {
     const keys = Object.keys(codecLayout);
     return Codec.from({
         encode(object) {
@@ -231,24 +216,24 @@ function table(codecLayout) {
                     const encodedItem = codecLayout[key].encode(object[key]);
                     const packedOffset = uint32To(result.offset);
                     return {
-                        header: (0, index_js_1.bytesConcat)(result.header, packedOffset),
-                        body: (0, index_js_1.bytesConcat)(result.body, encodedItem),
-                        offset: result.offset + (0, index_js_1.bytesFrom)(encodedItem).byteLength,
+                        header: bytesConcat(result.header, packedOffset),
+                        body: bytesConcat(result.body, encodedItem),
+                        offset: result.offset + bytesFrom(encodedItem).byteLength,
                     };
                 }
                 catch (e) {
                     throw new Error(`table.${key}(${e?.toString()})`);
                 }
             }, {
-                header: (0, index_js_1.bytesFrom)([]),
-                body: (0, index_js_1.bytesFrom)([]),
+                header: bytesFrom([]),
+                body: bytesFrom([]),
                 offset: headerLength,
             });
             const packedTotalSize = uint32To(header.byteLength + body.byteLength + 4);
-            return (0, index_js_1.bytesConcat)(packedTotalSize, header, body);
+            return bytesConcat(packedTotalSize, header, body);
         },
         decode(buffer) {
-            const value = (0, index_js_1.bytesFrom)(buffer);
+            const value = bytesFrom(buffer);
             const byteLength = uint32From(value.slice(0, 4));
             if (byteLength !== value.byteLength) {
                 throw new Error(`table: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`);
@@ -290,7 +275,7 @@ function table(codecLayout) {
  * // with custom id
  * union({ cafe: Uint8, bee: Uint8 }, { cafe: 0xcafe, bee: 0xbee })
  */
-function union(codecLayout, fields) {
+export function union(codecLayout, fields) {
     const keys = Object.keys(codecLayout);
     return Codec.from({
         encode({ type, value }) {
@@ -306,14 +291,14 @@ function union(codecLayout, fields) {
             const header = uint32To(fieldId);
             try {
                 const body = codec.encode(value);
-                return (0, index_js_1.bytesConcat)(header, body);
+                return bytesConcat(header, body);
             }
             catch (e) {
                 throw new Error(`union.(${typeStr})(${e?.toString()})`);
             }
         },
         decode(buffer) {
-            const value = (0, index_js_1.bytesFrom)(buffer);
+            const value = bytesFrom(buffer);
             const fieldIndex = uint32From(value.slice(0, 4));
             const keys = Object.keys(codecLayout);
             const field = (() => {
@@ -343,7 +328,7 @@ function union(codecLayout, fields) {
  * The size of a struct is the sum of all fields' size.
  * @param codecLayout a object contains all fields' codec
  */
-function struct(codecLayout) {
+export function struct(codecLayout) {
     const codecArray = Object.values(codecLayout);
     if (codecArray.some((codec) => codec.byteLength === undefined)) {
         throw new Error("struct: all fields must be fixed-size");
@@ -355,15 +340,15 @@ function struct(codecLayout) {
             return keys.reduce((result, key) => {
                 try {
                     const encodedItem = codecLayout[key].encode(object[key]);
-                    return (0, index_js_1.bytesConcat)(result, encodedItem);
+                    return bytesConcat(result, encodedItem);
                 }
                 catch (e) {
                     throw new Error(`struct.${key}(${e?.toString()})`);
                 }
-            }, (0, index_js_1.bytesFrom)([]));
+            }, bytesFrom([]));
         },
         decode(buffer) {
-            const value = (0, index_js_1.bytesFrom)(buffer);
+            const value = bytesFrom(buffer);
             const object = {};
             let offset = 0;
             Object.entries(codecLayout).forEach(([key, codec]) => {
@@ -387,7 +372,7 @@ function struct(codecLayout) {
  * @param itemCodec the fixed-size array item codec
  * @param itemCount
  */
-function array(itemCodec, itemCount) {
+export function array(itemCodec, itemCount) {
     if (itemCodec.byteLength === undefined) {
         throw new Error("array: itemCodec requires a byte length");
     }
@@ -396,14 +381,14 @@ function array(itemCodec, itemCount) {
         byteLength,
         encode(items) {
             try {
-                return items.reduce((concatted, item) => (0, index_js_1.bytesConcat)(concatted, itemCodec.encode(item)), (0, index_js_1.bytesFrom)([]));
+                return items.reduce((concatted, item) => bytesConcat(concatted, itemCodec.encode(item)), bytesFrom([]));
             }
             catch (e) {
                 throw new Error(`array(${e?.toString()})`);
             }
         },
         decode(buffer) {
-            const value = (0, index_js_1.bytesFrom)(buffer);
+            const value = bytesFrom(buffer);
             if (value.byteLength != byteLength) {
                 throw new Error(`array: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`);
             }
@@ -425,23 +410,23 @@ function array(itemCodec, itemCount) {
  * @param byteLength
  * @param littleEndian
  */
-function uint(byteLength, littleEndian = false) {
+export function uint(byteLength, littleEndian = false) {
     return Codec.from({
         byteLength,
         encode: (numLike) => {
             if (littleEndian) {
-                return (0, index_js_2.numToBytes)(numLike, byteLength);
+                return numToBytes(numLike, byteLength);
             }
             else {
-                return (0, index_js_2.numBeToBytes)(numLike, byteLength);
+                return numBeToBytes(numLike, byteLength);
             }
         },
         decode: (buffer) => {
             if (littleEndian) {
-                return (0, index_js_2.numFromBytes)(buffer);
+                return numFromBytes(buffer);
             }
             else {
-                return (0, index_js_2.numBeFromBytes)(buffer);
+                return numBeFromBytes(buffer);
             }
         },
     });
@@ -451,7 +436,7 @@ function uint(byteLength, littleEndian = false) {
  * @param byteLength
  * @param littleEndian
  */
-function uintNumber(byteLength, littleEndian = false) {
+export function uintNumber(byteLength, littleEndian = false) {
     if (byteLength > 4) {
         throw new Error("uintNumber: byteLength must be less than or equal to 4");
     }

package/dist.commonjs/molecule/index.js

@@ -1,18 +1,2 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./codec.js"), exports);
-__exportStar(require("./predefined.js"), exports);
+export * from "./codec.js";
+export * from "./predefined.js";