@ckb-ccc/core 0.1.0 → 0.1.2

package/dist.commonjs/hasher/hasherCkb.js

@@ -1,21 +1,26 @@
-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";
+"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");
 /**
  * @public
  */
-export class HasherCkb {
+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 = CKB_BLAKE2B_PERSONAL) {
-        this.hasher = blake2b.create({
+    constructor(outLength = 32, personal = advanced_js_1.CKB_BLAKE2B_PERSONAL) {
+        this.hasher = blake2b_1.blake2b.create({
             personalization: personal,
             dkLen: outLength,
         });
@@ -34,7 +39,7 @@ export class HasherCkb {
      * ```
      */
     update(data) {
-        this.hasher.update(bytesFrom(data));
+        this.hasher.update((0, index_js_1.bytesFrom)(data));
         return this;
     }
     /**
@@ -50,9 +55,10 @@ export class HasherCkb {
      * ```
      */
     digest() {
-        return hexFrom(this.hasher.digest());
+        return (0, index_js_3.hexFrom)(this.hasher.digest());
     }
 }
+exports.HasherCkb = HasherCkb;
 /**
  * Computes the CKB hash of the given data using the Blake2b algorithm.
  * @public
@@ -65,7 +71,7 @@ export class HasherCkb {
  * const hash = hashCkb("some data"); // Outputs something like "0x..."
  * ```
  */
-export function hashCkb(...data) {
+function hashCkb(...data) {
     const hasher = new HasherCkb();
     data.forEach((d) => hasher.update(d));
     return hasher.digest();
@@ -83,6 +89,6 @@ export function hashCkb(...data) {
  * const hash = hashTypeId(cellInput, outputIndex); // Outputs something like "0x..."
  * ```
  */
-export function hashTypeId(cellInputLike, outputIndex) {
-    return hashCkb(CellInput.from(cellInputLike).toBytes(), numLeToBytes(outputIndex, 8));
+function hashTypeId(cellInputLike, outputIndex) {
+    return hashCkb(index_js_2.CellInput.from(cellInputLike).toBytes(), (0, index_js_4.numLeToBytes)(outputIndex, 8));
 }

package/dist.commonjs/hasher/hasherKeecak256.js

@@ -1,15 +1,18 @@
-import { keccak_256 } from "@noble/hashes/sha3";
-import { bytesFrom } from "../bytes/index.js";
-import { hexFrom } from "../hex/index.js";
+"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");
 /**
  * @public
  */
-export class HasherKeecak256 {
+class HasherKeecak256 {
     /**
      * Creates an instance of Hasher.
      */
     constructor() {
-        this.hasher = keccak_256.create();
+        this.hasher = sha3_1.keccak_256.create();
     }
     /**
      * Updates the hash with the given data.
@@ -25,7 +28,7 @@ export class HasherKeecak256 {
      * ```
      */
     update(data) {
-        this.hasher.update(bytesFrom(data));
+        this.hasher.update((0, index_js_1.bytesFrom)(data));
         return this;
     }
     /**
@@ -41,6 +44,7 @@ export class HasherKeecak256 {
      * ```
      */
     digest() {
-        return hexFrom(this.hasher.digest());
+        return (0, index_js_2.hexFrom)(this.hasher.digest());
     }
 }
+exports.HasherKeecak256 = HasherKeecak256;

package/dist.commonjs/hasher/index.js

@@ -1,3 +1,19 @@
-export * from "./hasher.js";
-export * from "./hasherCkb.js";
-export * from "./hasherKeecak256.js";
+"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);

package/dist.commonjs/hex/index.js

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

package/dist.commonjs/index.js

@@ -1,2 +1,31 @@
-export * from "./barrel.js";
-export * as ccc from "./barrel.js";
+"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"));

package/dist.commonjs/keystore/index.js

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

package/dist.commonjs/molecule/codec.js

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