@solana/codecs-data-structures 2.0.0-experimental.fc4e943 → 2.0.0-experimental.fcff844

package/dist/index.development.js

@@ -14,28 +14,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
       throw new Error(`Codec [${codecDescription}] expected ${expected} bytes, got ${bytesLength}.`);
     }
   }
-  function assertFixedSizeCodec(data, message) {
-    if (data.fixedSize === null) {
-      throw new Error(message ?? "Expected a fixed-size codec, got a variable-size one.");
-    }
-  }
-  var mergeBytes = (byteArrays) => {
-    const nonEmptyByteArrays = byteArrays.filter((arr) => arr.length);
-    if (nonEmptyByteArrays.length === 0) {
-      return byteArrays.length ? byteArrays[0] : new Uint8Array();
-    }
-    if (nonEmptyByteArrays.length === 1) {
-      return nonEmptyByteArrays[0];
-    }
-    const totalLength = nonEmptyByteArrays.reduce((total, arr) => total + arr.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    nonEmptyByteArrays.forEach((arr) => {
-      result.set(arr, offset);
-      offset += arr.length;
-    });
-    return result;
-  };
   var padBytes = (bytes, length) => {
     if (bytes.length >= length)
       return bytes;
@@ -44,58 +22,100 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return paddedBytes;
   };
   var fixBytes = (bytes, length) => padBytes(bytes.length <= length ? bytes : bytes.slice(0, length), length);
-  function combineCodec(encoder, decoder, description) {
-    if (encoder.fixedSize !== decoder.fixedSize) {
+  function getEncodedSize(value, encoder) {
+    return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
+  }
+  function createEncoder(encoder) {
+    return Object.freeze({
+      ...encoder,
+      encode: (value) => {
+        const bytes = new Uint8Array(getEncodedSize(value, encoder));
+        encoder.write(value, bytes, 0);
+        return bytes;
+      }
+    });
+  }
+  function createDecoder(decoder) {
+    return Object.freeze({
+      ...decoder,
+      decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
+    });
+  }
+  function isFixedSize(codec) {
+    return "fixedSize" in codec && typeof codec.fixedSize === "number";
+  }
+  function assertIsFixedSize(codec, message) {
+    if (!isFixedSize(codec)) {
+      throw new Error(message != null ? message : "Expected a fixed-size codec, got a variable-size one.");
+    }
+  }
+  function isVariableSize(codec) {
+    return !isFixedSize(codec);
+  }
+  function combineCodec(encoder, decoder) {
+    if (isFixedSize(encoder) !== isFixedSize(decoder)) {
+      throw new Error(`Encoder and decoder must either both be fixed-size or variable-size.`);
+    }
+    if (isFixedSize(encoder) && isFixedSize(decoder) && encoder.fixedSize !== decoder.fixedSize) {
       throw new Error(
         `Encoder and decoder must have the same fixed size, got [${encoder.fixedSize}] and [${decoder.fixedSize}].`
       );
     }
-    if (encoder.maxSize !== decoder.maxSize) {
+    if (!isFixedSize(encoder) && !isFixedSize(decoder) && encoder.maxSize !== decoder.maxSize) {
       throw new Error(
         `Encoder and decoder must have the same max size, got [${encoder.maxSize}] and [${decoder.maxSize}].`
       );
     }
-    if (description === void 0 && encoder.description !== decoder.description) {
-      throw new Error(
-        `Encoder and decoder must have the same description, got [${encoder.description}] and [${decoder.description}]. Pass a custom description as a third argument if you want to override the description and bypass this error.`
-      );
-    }
     return {
+      ...decoder,
+      ...encoder,
       decode: decoder.decode,
-      description: description ?? encoder.description,
       encode: encoder.encode,
-      fixedSize: encoder.fixedSize,
-      maxSize: encoder.maxSize
+      read: decoder.read,
+      write: encoder.write
     };
   }
-  function fixCodecHelper(data, fixedBytes, description) {
-    return {
-      description: description ?? `fixed(${fixedBytes}, ${data.description})`,
+  function fixEncoder(encoder, fixedBytes) {
+    return createEncoder({
       fixedSize: fixedBytes,
-      maxSize: fixedBytes
-    };
-  }
-  function fixEncoder(encoder, fixedBytes, description) {
-    return {
-      ...fixCodecHelper(encoder, fixedBytes, description),
-      encode: (value) => fixBytes(encoder.encode(value), fixedBytes)
-    };
+      write: (value, bytes, offset) => {
+        const variableByteArray = encoder.encode(value);
+        const fixedByteArray = variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;
+        bytes.set(fixedByteArray, offset);
+        return offset + fixedBytes;
+      }
+    });
   }
-  function fixDecoder(decoder, fixedBytes, description) {
-    return {
-      ...fixCodecHelper(decoder, fixedBytes, description),
-      decode: (bytes, offset = 0) => {
+  function fixDecoder(decoder, fixedBytes) {
+    return createDecoder({
+      fixedSize: fixedBytes,
+      read: (bytes, offset) => {
         assertByteArrayHasEnoughBytesForCodec("fixCodec", fixedBytes, bytes, offset);
         if (offset > 0 || bytes.length > fixedBytes) {
           bytes = bytes.slice(offset, offset + fixedBytes);
         }
-        if (decoder.fixedSize !== null) {
+        if (isFixedSize(decoder)) {
           bytes = fixBytes(bytes, decoder.fixedSize);
         }
-        const [value] = decoder.decode(bytes, 0);
+        const [value] = decoder.read(bytes, 0);
         return [value, offset + fixedBytes];
       }
-    };
+    });
+  }
+  function mapEncoder(encoder, unmap) {
+    return createEncoder({
+      ...isVariableSize(encoder) ? { ...encoder, getSizeFromValue: (value) => encoder.getSizeFromValue(unmap(value)) } : encoder,
+      write: (value, bytes, offset) => encoder.write(unmap(value), bytes, offset)
+    });
+  }
+  function mapDecoder(decoder, map) {
+    return createDecoder({
+      ...decoder,
+      read: (bytes, offset) => {
+        const [value, newOffset] = decoder.read(bytes, offset);
+        return [map(value, bytes, offset), newOffset];
+      }
+    });
   }
 
   // ../codecs-numbers/dist/index.browser.js
@@ -106,82 +126,71 @@ this.globalThis.solanaWeb3 = (function (exports) {
       );
     }
   }
-  function sharedNumberFactory(input) {
-    let littleEndian;
-    let defaultDescription = input.name;
-    if (input.size > 1) {
-      littleEndian = !("endian" in input.options) || input.options.endian === 0;
-      defaultDescription += littleEndian ? "(le)" : "(be)";
-    }
-    return {
-      description: input.options.description ?? defaultDescription,
-      fixedSize: input.size,
-      littleEndian,
-      maxSize: input.size
-    };
+  function isLittleEndian(config) {
+    return (config == null ? void 0 : config.endian) === 1 ? false : true;
   }
   function numberEncoderFactory(input) {
-    const codecData = sharedNumberFactory(input);
-    return {
-      description: codecData.description,
-      encode(value) {
+    return createEncoder({
+      fixedSize: input.size,
+      write(value, bytes, offset) {
         if (input.range) {
           assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
         }
         const arrayBuffer = new ArrayBuffer(input.size);
-        input.set(new DataView(arrayBuffer), value, codecData.littleEndian);
-        return new Uint8Array(arrayBuffer);
-      },
-      fixedSize: codecData.fixedSize,
-      maxSize: codecData.maxSize
-    };
+        input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+        bytes.set(new Uint8Array(arrayBuffer), offset);
+        return offset + input.size;
+      }
+    });
   }
   function numberDecoderFactory(input) {
-    const codecData = sharedNumberFactory(input);
-    return {
-      decode(bytes, offset = 0) {
-        assertByteArrayIsNotEmptyForCodec(codecData.description, bytes, offset);
-        assertByteArrayHasEnoughBytesForCodec(codecData.description, input.size, bytes, offset);
+    return createDecoder({
+      fixedSize: input.size,
+      read(bytes, offset = 0) {
+        assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+        assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
         const view = new DataView(toArrayBuffer(bytes, offset, input.size));
-        return [input.get(view, codecData.littleEndian), offset + input.size];
-      },
-      description: codecData.description,
-      fixedSize: codecData.fixedSize,
-      maxSize: codecData.maxSize
-    };
+        return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+      }
+    });
   }
   function toArrayBuffer(bytes, offset, length) {
-    const bytesOffset = bytes.byteOffset + (offset ?? 0);
-    const bytesLength = length ?? bytes.byteLength;
+    const bytesOffset = bytes.byteOffset + (offset != null ? offset : 0);
+    const bytesLength = length != null ? length : bytes.byteLength;
     return bytes.buffer.slice(bytesOffset, bytesOffset + bytesLength);
   }
-  var getU32Encoder = (options = {}) => numberEncoderFactory({
+  var getU32Encoder = (config = {}) => numberEncoderFactory({
+    config,
     name: "u32",
-    options,
     range: [0, Number("0xffffffff")],
     set: (view, value, le) => view.setUint32(0, value, le),
     size: 4
   });
-  var getU32Decoder = (options = {}) => numberDecoderFactory({
+  var getU32Decoder = (config = {}) => numberDecoderFactory({
+    config,
     get: (view, le) => view.getUint32(0, le),
     name: "u32",
-    options,
     size: 4
   });
-  var getU8Encoder = (options = {}) => numberEncoderFactory({
+  var getU8Encoder = () => numberEncoderFactory({
     name: "u8",
-    options,
     range: [0, Number("0xff")],
     set: (view, value) => view.setUint8(0, value),
     size: 1
   });
-  var getU8Decoder = (options = {}) => numberDecoderFactory({
+  var getU8Decoder = () => numberDecoderFactory({
     get: (view) => view.getUint8(0),
     name: "u8",
-    options,
     size: 1
   });
 
+  // src/assertions.ts
+  function assertValidNumberOfItemsForCodec(codecDescription, expected, actual) {
+    if (expected !== actual) {
+      throw new Error(`Expected [${codecDescription}] to have ${expected} items, got ${actual}.`);
+    }
+  }
+
   // src/utils.ts
   function maxCodecSizes(sizes) {
     return sizes.reduce(
@@ -192,132 +201,138 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function sumCodecSizes(sizes) {
     return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
   }
+  function getFixedSize(codec) {
+    return isFixedSize(codec) ? codec.fixedSize : null;
+  }
+  function getMaxSize(codec) {
+    var _a;
+    return isFixedSize(codec) ? codec.fixedSize : (_a = codec.maxSize) != null ? _a : null;
+  }
 
-  // src/array-like-codec-size.ts
-  function decodeArrayLikeCodecSize(size, childrenSizes, bytes, offset) {
+  // src/array.ts
+  function getArrayEncoder(item, config = {}) {
+    var _a, _b;
+    const size = (_a = config.size) != null ? _a : getU32Encoder();
+    if (size === "remainder") {
+      assertIsFixedSize(item, 'Codecs of "remainder" size must have fixed-size items.');
+    }
+    const fixedSize = computeArrayLikeCodecSize(size, getFixedSize(item));
+    const maxSize = (_b = computeArrayLikeCodecSize(size, getMaxSize(item))) != null ? _b : void 0;
+    return createEncoder({
+      ...fixedSize !== null ? { fixedSize } : {
+        getSizeFromValue: (array) => {
+          const prefixSize = typeof size === "object" ? getEncodedSize(array.length, size) : 0;
+          return prefixSize + [...array].reduce((all, value) => all + getEncodedSize(value, item), 0);
+        },
+        maxSize
+      },
+      write: (array, bytes, offset) => {
+        if (typeof size === "number") {
+          assertValidNumberOfItemsForCodec("array", size, array.length);
+        }
+        if (typeof size === "object") {
+          offset = size.write(array.length, bytes, offset);
+        }
+        array.forEach((value) => {
+          offset = item.write(value, bytes, offset);
+        });
+        return offset;
+      }
+    });
+  }
+  function getArrayDecoder(item, config = {}) {
+    var _a, _b;
+    const size = (_a = config.size) != null ? _a : getU32Decoder();
+    if (size === "remainder") {
+      assertIsFixedSize(item, 'Codecs of "remainder" size must have fixed-size items.');
+    }
+    const itemSize = getFixedSize(item);
+    const fixedSize = computeArrayLikeCodecSize(size, itemSize);
+    const maxSize = (_b = computeArrayLikeCodecSize(size, getMaxSize(item))) != null ? _b : void 0;
+    return createDecoder({
+      ...fixedSize !== null ? { fixedSize } : { maxSize },
+      read: (bytes, offset) => {
+        const array = [];
+        if (typeof size === "object" && bytes.slice(offset).length === 0) {
+          return [array, offset];
+        }
+        const [resolvedSize, newOffset] = readArrayLikeCodecSize(size, itemSize, bytes, offset);
+        offset = newOffset;
+        for (let i = 0; i < resolvedSize; i += 1) {
+          const [value, newOffset2] = item.read(bytes, offset);
+          offset = newOffset2;
+          array.push(value);
+        }
+        return [array, offset];
+      }
+    });
+  }
+  function getArrayCodec(item, config = {}) {
+    return combineCodec(getArrayEncoder(item, config), getArrayDecoder(item, config));
+  }
+  function readArrayLikeCodecSize(size, itemSize, bytes, offset) {
     if (typeof size === "number") {
       return [size, offset];
     }
     if (typeof size === "object") {
-      return size.decode(bytes, offset);
+      return size.read(bytes, offset);
     }
     if (size === "remainder") {
-      const childrenSize = sumCodecSizes(childrenSizes);
-      if (childrenSize === null) {
+      if (itemSize === null) {
         throw new Error('Codecs of "remainder" size must have fixed-size items.');
       }
-      const remainder = bytes.slice(offset).length;
-      if (remainder % childrenSize !== 0) {
+      const remainder = Math.max(0, bytes.length - offset);
+      if (remainder % itemSize !== 0) {
         throw new Error(
-          `The remainder of the byte array (${remainder} bytes) cannot be split into chunks of ${childrenSize} bytes. Codecs of "remainder" size must have a remainder that is a multiple of its item size. In other words, ${remainder} modulo ${childrenSize} should be equal to zero.`
+          `The remainder of the byte array (${remainder} bytes) cannot be split into chunks of ${itemSize} bytes. Codecs of "remainder" size must have a remainder that is a multiple of its item size. In other words, ${remainder} modulo ${itemSize} should be equal to zero.`
         );
       }
-      return [remainder / childrenSize, offset];
+      return [remainder / itemSize, offset];
     }
     throw new Error(`Unrecognized array-like codec size: ${JSON.stringify(size)}`);
   }
-  function getArrayLikeCodecSizeDescription(size) {
-    return typeof size === "object" ? size.description : `${size}`;
-  }
-  function getArrayLikeCodecSizeFromChildren(size, childrenSizes) {
+  function computeArrayLikeCodecSize(size, itemSize) {
     if (typeof size !== "number")
       return null;
     if (size === 0)
       return 0;
-    const childrenSize = sumCodecSizes(childrenSizes);
-    return childrenSize === null ? null : childrenSize * size;
-  }
-  function getArrayLikeCodecSizePrefix(size, realSize) {
-    return typeof size === "object" ? size.encode(realSize) : new Uint8Array();
-  }
-
-  // src/assertions.ts
-  function assertValidNumberOfItemsForCodec(codecDescription, expected, actual) {
-    if (expected !== actual) {
-      throw new Error(`Expected [${codecDescription}] to have ${expected} items, got ${actual}.`);
-    }
-  }
-
-  // src/array.ts
-  function arrayCodecHelper(item, size, description) {
-    if (size === "remainder" && item.fixedSize === null) {
-      throw new Error('Codecs of "remainder" size must have fixed-size items.');
-    }
-    return {
-      description: description ?? `array(${item.description}; ${getArrayLikeCodecSizeDescription(size)})`,
-      fixedSize: getArrayLikeCodecSizeFromChildren(size, [item.fixedSize]),
-      maxSize: getArrayLikeCodecSizeFromChildren(size, [item.maxSize])
-    };
-  }
-  function getArrayEncoder(item, options = {}) {
-    const size = options.size ?? getU32Encoder();
-    return {
-      ...arrayCodecHelper(item, size, options.description),
-      encode: (value) => {
-        if (typeof size === "number") {
-          assertValidNumberOfItemsForCodec("array", size, value.length);
-        }
-        return mergeBytes([getArrayLikeCodecSizePrefix(size, value.length), ...value.map((v) => item.encode(v))]);
-      }
-    };
-  }
-  function getArrayDecoder(item, options = {}) {
-    const size = options.size ?? getU32Decoder();
-    return {
-      ...arrayCodecHelper(item, size, options.description),
-      decode: (bytes, offset = 0) => {
-        if (typeof size === "object" && bytes.slice(offset).length === 0) {
-          return [[], offset];
-        }
-        const [resolvedSize, newOffset] = decodeArrayLikeCodecSize(size, [item.fixedSize], bytes, offset);
-        offset = newOffset;
-        const values = [];
-        for (let i = 0; i < resolvedSize; i += 1) {
-          const [value, newOffset2] = item.decode(bytes, offset);
-          values.push(value);
-          offset = newOffset2;
-        }
-        return [values, offset];
-      }
-    };
-  }
-  function getArrayCodec(item, options = {}) {
-    return combineCodec(getArrayEncoder(item, options), getArrayDecoder(item, options));
+    return itemSize === null ? null : itemSize * size;
   }
 
   // src/bit-array.ts
-  var getBitArrayEncoder = (size, options = {}) => {
-    const parsedOptions = typeof options === "boolean" ? { backward: options } : options;
-    const backward = parsedOptions.backward ?? false;
-    const backwardSuffix = backward ? "; backward" : "";
-    return {
-      description: parsedOptions.description ?? `bitArray(${size}${backwardSuffix})`,
-      encode(value) {
-        const bytes = [];
+  function getBitArrayEncoder(size, config = {}) {
+    var _a;
+    const parsedConfig = typeof config === "boolean" ? { backward: config } : config;
+    const backward = (_a = parsedConfig.backward) != null ? _a : false;
+    return createEncoder({
+      fixedSize: size,
+      write(value, bytes, offset) {
+        var _a2;
+        const bytesToAdd = [];
         for (let i = 0; i < size; i += 1) {
           let byte = 0;
           for (let j = 0; j < 8; j += 1) {
-            const feature = Number(value[i * 8 + j] ?? 0);
+            const feature = Number((_a2 = value[i * 8 + j]) != null ? _a2 : 0);
             byte |= feature << (backward ? j : 7 - j);
           }
           if (backward) {
-            bytes.unshift(byte);
+            bytesToAdd.unshift(byte);
           } else {
-            bytes.push(byte);
+            bytesToAdd.push(byte);
           }
         }
-        return new Uint8Array(bytes);
-      },
+        bytes.set(bytesToAdd, offset);
+        return size;
+      }
+    });
+  }
+  function getBitArrayDecoder(size, config = {}) {
+    var _a;
+    const parsedConfig = typeof config === "boolean" ? { backward: config } : config;
+    const backward = (_a = parsedConfig.backward) != null ? _a : false;
+    return createDecoder({
       fixedSize: size,
-      maxSize: size
-    };
-  };
-  var getBitArrayDecoder = (size, options = {}) => {
-    const parsedOptions = typeof options === "boolean" ? { backward: options } : options;
-    const backward = parsedOptions.backward ?? false;
-    const backwardSuffix = backward ? "; backward" : "";
-    return {
-      decode(bytes, offset = 0) {
+      read(bytes, offset) {
         assertByteArrayHasEnoughBytesForCodec("bitArray", size, bytes, offset);
         const booleans = [];
         let slice = bytes.slice(offset, offset + size);
@@ -334,496 +349,416 @@ this.globalThis.solanaWeb3 = (function (exports) {
           }
         });
         return [booleans, offset + size];
-      },
-      description: parsedOptions.description ?? `bitArray(${size}${backwardSuffix})`,
-      fixedSize: size,
-      maxSize: size
-    };
-  };
-  var getBitArrayCodec = (size, options = {}) => combineCodec(getBitArrayEncoder(size, options), getBitArrayDecoder(size, options));
+      }
+    });
+  }
+  function getBitArrayCodec(size, config = {}) {
+    return combineCodec(getBitArrayEncoder(size, config), getBitArrayDecoder(size, config));
+  }
 
   // src/boolean.ts
-  function getBooleanEncoder(options = {}) {
-    const size = options.size ?? getU8Encoder();
-    assertFixedSizeCodec(size, "Codec [bool] requires a fixed size.");
-    return {
-      description: options.description ?? `bool(${size.description})`,
-      encode: (value) => size.encode(value ? 1 : 0),
-      fixedSize: size.fixedSize,
-      maxSize: size.fixedSize
-    };
+  function getBooleanEncoder(config = {}) {
+    var _a;
+    const size = (_a = config.size) != null ? _a : getU8Encoder();
+    assertIsFixedSize(size, "Codec [bool] requires a fixed size.");
+    return mapEncoder(size, (value) => value ? 1 : 0);
   }
-  function getBooleanDecoder(options = {}) {
-    const size = options.size ?? getU8Decoder();
-    assertFixedSizeCodec(size, "Codec [bool] requires a fixed size.");
-    return {
-      decode: (bytes, offset = 0) => {
-        assertByteArrayIsNotEmptyForCodec("bool", bytes, offset);
-        const [value, vOffset] = size.decode(bytes, offset);
-        return [value === 1, vOffset];
-      },
-      description: options.description ?? `bool(${size.description})`,
-      fixedSize: size.fixedSize,
-      maxSize: size.fixedSize
-    };
+  function getBooleanDecoder(config = {}) {
+    var _a;
+    const size = (_a = config.size) != null ? _a : getU8Decoder();
+    assertIsFixedSize(size, "Codec [bool] requires a fixed size.");
+    return mapDecoder(size, (value) => Number(value) === 1);
   }
-  function getBooleanCodec(options = {}) {
-    return combineCodec(getBooleanEncoder(options), getBooleanDecoder(options));
+  function getBooleanCodec(config = {}) {
+    return combineCodec(getBooleanEncoder(config), getBooleanDecoder(config));
   }
 
   // src/bytes.ts
-  function getBytesEncoder(options = {}) {
-    const size = options.size ?? "variable";
-    const sizeDescription = typeof size === "object" ? size.description : `${size}`;
-    const description = options.description ?? `bytes(${sizeDescription})`;
-    const byteEncoder = {
-      description,
-      encode: (value) => value,
-      fixedSize: null,
-      maxSize: null
-    };
+  function getBytesEncoder(config = {}) {
+    var _a;
+    const size = (_a = config.size) != null ? _a : "variable";
+    const byteEncoder = createEncoder({
+      getSizeFromValue: (value) => value.length,
+      write: (value, bytes, offset) => {
+        bytes.set(value, offset);
+        return offset + value.length;
+      }
+    });
     if (size === "variable") {
       return byteEncoder;
     }
     if (typeof size === "number") {
-      return fixEncoder(byteEncoder, size, description);
+      return fixEncoder(byteEncoder, size);
     }
-    return {
-      ...byteEncoder,
-      encode: (value) => {
-        const contentBytes = byteEncoder.encode(value);
-        const lengthBytes = size.encode(contentBytes.length);
-        return mergeBytes([lengthBytes, contentBytes]);
+    return createEncoder({
+      getSizeFromValue: (value) => getEncodedSize(value.length, size) + value.length,
+      write: (value, bytes, offset) => {
+        offset = size.write(value.length, bytes, offset);
+        return byteEncoder.write(value, bytes, offset);
       }
-    };
+    });
   }
-  function getBytesDecoder(options = {}) {
-    const size = options.size ?? "variable";
-    const sizeDescription = typeof size === "object" ? size.description : `${size}`;
-    const description = options.description ?? `bytes(${sizeDescription})`;
-    const byteDecoder = {
-      decode: (bytes, offset = 0) => {
+  function getBytesDecoder(config = {}) {
+    var _a;
+    const size = (_a = config.size) != null ? _a : "variable";
+    const byteDecoder = createDecoder({
+      read: (bytes, offset) => {
         const slice = bytes.slice(offset);
         return [slice, offset + slice.length];
-      },
-      description,
-      fixedSize: null,
-      maxSize: null
-    };
+      }
+    });
     if (size === "variable") {
       return byteDecoder;
     }
     if (typeof size === "number") {
-      return fixDecoder(byteDecoder, size, description);
+      return fixDecoder(byteDecoder, size);
     }
-    return {
-      ...byteDecoder,
-      decode: (bytes, offset = 0) => {
+    return createDecoder({
+      read: (bytes, offset) => {
         assertByteArrayIsNotEmptyForCodec("bytes", bytes, offset);
-        const [lengthBigInt, lengthOffset] = size.decode(bytes, offset);
+        const [lengthBigInt, lengthOffset] = size.read(bytes, offset);
         const length = Number(lengthBigInt);
         offset = lengthOffset;
         const contentBytes = bytes.slice(offset, offset + length);
         assertByteArrayHasEnoughBytesForCodec("bytes", length, contentBytes);
-        const [value, contentOffset] = byteDecoder.decode(contentBytes);
+        const [value, contentOffset] = byteDecoder.read(contentBytes, 0);
         offset += contentOffset;
         return [value, offset];
       }
-    };
+    });
   }
-  function getBytesCodec(options = {}) {
-    return combineCodec(getBytesEncoder(options), getBytesDecoder(options));
+  function getBytesCodec(config = {}) {
+    return combineCodec(getBytesEncoder(config), getBytesDecoder(config));
   }
 
   // src/data-enum.ts
-  function dataEnumCodecHelper(variants, prefix, description) {
-    const fieldDescriptions = variants.map(([name, codec]) => `${String(name)}${codec ? `: ${codec.description}` : ""}`).join(", ");
-    const allVariantHaveTheSameFixedSize = variants.every((one, _i, all) => one[1].fixedSize === all[0][1].fixedSize);
-    const fixedVariantSize = allVariantHaveTheSameFixedSize ? variants[0][1].fixedSize : null;
-    const maxVariantSize = maxCodecSizes(variants.map(([, field]) => field.maxSize));
-    return {
-      description: description ?? `dataEnum(${fieldDescriptions}; ${prefix.description})`,
-      fixedSize: variants.length === 0 ? prefix.fixedSize : sumCodecSizes([prefix.fixedSize, fixedVariantSize]),
-      maxSize: variants.length === 0 ? prefix.maxSize : sumCodecSizes([prefix.maxSize, maxVariantSize])
-    };
-  }
-  function getDataEnumEncoder(variants, options = {}) {
-    const prefix = options.size ?? getU8Encoder();
-    return {
-      ...dataEnumCodecHelper(variants, prefix, options.description),
-      encode: (variant) => {
-        const discriminator = variants.findIndex(([key]) => variant.__kind === key);
-        if (discriminator < 0) {
-          throw new Error(
-            `Invalid data enum variant. Expected one of [${variants.map(([key]) => key).join(", ")}], got "${variant.__kind}".`
-          );
-        }
-        const variantPrefix = prefix.encode(discriminator);
-        const variantSerializer = variants[discriminator][1];
-        const variantBytes = variantSerializer.encode(variant);
-        return mergeBytes([variantPrefix, variantBytes]);
+  function getDataEnumEncoder(variants, config = {}) {
+    var _a;
+    const prefix = (_a = config.size) != null ? _a : getU8Encoder();
+    const fixedSize = getDataEnumFixedSize(variants, prefix);
+    return createEncoder({
+      ...fixedSize !== null ? { fixedSize } : {
+        getSizeFromValue: (variant) => {
+          const discriminator = getVariantDiscriminator(variants, variant);
+          const variantEncoder = variants[discriminator][1];
+          return getEncodedSize(discriminator, prefix) + getEncodedSize(variant, variantEncoder);
+        },
+        maxSize: getDataEnumMaxSize(variants, prefix)
+      },
+      write: (variant, bytes, offset) => {
+        const discriminator = getVariantDiscriminator(variants, variant);
+        offset = prefix.write(discriminator, bytes, offset);
+        const variantEncoder = variants[discriminator][1];
+        return variantEncoder.write(variant, bytes, offset);
       }
-    };
+    });
   }
-  function getDataEnumDecoder(variants, options = {}) {
-    const prefix = options.size ?? getU8Decoder();
-    return {
-      ...dataEnumCodecHelper(variants, prefix, options.description),
-      decode: (bytes, offset = 0) => {
+  function getDataEnumDecoder(variants, config = {}) {
+    var _a;
+    const prefix = (_a = config.size) != null ? _a : getU8Decoder();
+    const fixedSize = getDataEnumFixedSize(variants, prefix);
+    return createDecoder({
+      ...fixedSize !== null ? { fixedSize } : { maxSize: getDataEnumMaxSize(variants, prefix) },
+      read: (bytes, offset) => {
+        var _a2;
         assertByteArrayIsNotEmptyForCodec("dataEnum", bytes, offset);
-        const [discriminator, dOffset] = prefix.decode(bytes, offset);
+        const [discriminator, dOffset] = prefix.read(bytes, offset);
         offset = dOffset;
-        const variantField = variants[Number(discriminator)] ?? null;
+        const variantField = (_a2 = variants[Number(discriminator)]) != null ? _a2 : null;
         if (!variantField) {
           throw new Error(
             `Enum discriminator out of range. Expected a number between 0 and ${variants.length - 1}, got ${discriminator}.`
           );
         }
-        const [variant, vOffset] = variantField[1].decode(bytes, offset);
+        const [variant, vOffset] = variantField[1].read(bytes, offset);
         offset = vOffset;
-        return [{ __kind: variantField[0], ...variant ?? {} }, offset];
+        return [{ __kind: variantField[0], ...variant != null ? variant : {} }, offset];
       }
-    };
+    });
   }
-  function getDataEnumCodec(variants, options = {}) {
-    return combineCodec(getDataEnumEncoder(variants, options), getDataEnumDecoder(variants, options));
+  function getDataEnumCodec(variants, config = {}) {
+    return combineCodec(getDataEnumEncoder(variants, config), getDataEnumDecoder(variants, config));
   }
-
-  // src/map.ts
-  function mapCodecHelper(key, value, size, description) {
-    if (size === "remainder" && (key.fixedSize === null || value.fixedSize === null)) {
-      throw new Error('Codecs of "remainder" size must have fixed-size items.');
+  function getDataEnumFixedSize(variants, prefix) {
+    if (variants.length === 0)
+      return isFixedSize(prefix) ? prefix.fixedSize : null;
+    if (!isFixedSize(variants[0][1]))
+      return null;
+    const variantSize = variants[0][1].fixedSize;
+    const sameSizedVariants = variants.every(
+      (variant) => isFixedSize(variant[1]) && variant[1].fixedSize === variantSize
+    );
+    if (!sameSizedVariants)
+      return null;
+    return isFixedSize(prefix) ? prefix.fixedSize + variantSize : null;
+  }
+  function getDataEnumMaxSize(variants, prefix) {
+    var _a;
+    const maxVariantSize = maxCodecSizes(variants.map(([, codec]) => getMaxSize(codec)));
+    return (_a = sumCodecSizes([getMaxSize(prefix), maxVariantSize])) != null ? _a : void 0;
+  }
+  function getVariantDiscriminator(variants, variant) {
+    const discriminator = variants.findIndex(([key]) => variant.__kind === key);
+    if (discriminator < 0) {
+      throw new Error(
+        `Invalid data enum variant. Expected one of [${variants.map(([key]) => key).join(", ")}], got "${variant.__kind}".`
+      );
     }
-    return {
-      description: description ?? `map(${key.description}, ${value.description}; ${getArrayLikeCodecSizeDescription(size)})`,
-      fixedSize: getArrayLikeCodecSizeFromChildren(size, [key.fixedSize, value.fixedSize]),
-      maxSize: getArrayLikeCodecSizeFromChildren(size, [key.maxSize, value.maxSize])
-    };
+    return discriminator;
   }
-  function getMapEncoder(key, value, options = {}) {
-    const size = options.size ?? getU32Encoder();
-    return {
-      ...mapCodecHelper(key, value, size, options.description),
-      encode: (map) => {
-        if (typeof size === "number") {
-          assertValidNumberOfItemsForCodec("map", size, map.size);
-        }
-        const itemBytes = Array.from(map, ([k, v]) => mergeBytes([key.encode(k), value.encode(v)]));
-        return mergeBytes([getArrayLikeCodecSizePrefix(size, map.size), ...itemBytes]);
+
+  // src/tuple.ts
+  function getTupleEncoder(items) {
+    var _a;
+    const fixedSize = sumCodecSizes(items.map(getFixedSize));
+    const maxSize = (_a = sumCodecSizes(items.map(getMaxSize))) != null ? _a : void 0;
+    return createEncoder({
+      ...fixedSize === null ? {
+        getSizeFromValue: (value) => items.map((item, index) => getEncodedSize(value[index], item)).reduce((all, one) => all + one, 0),
+        maxSize
+      } : { fixedSize },
+      write: (value, bytes, offset) => {
+        assertValidNumberOfItemsForCodec("tuple", items.length, value.length);
+        items.forEach((item, index) => {
+          offset = item.write(value[index], bytes, offset);
+        });
+        return offset;
       }
-    };
+    });
   }
-  function getMapDecoder(key, value, options = {}) {
-    const size = options.size ?? getU32Decoder();
-    return {
-      ...mapCodecHelper(key, value, size, options.description),
-      decode: (bytes, offset = 0) => {
-        const map = /* @__PURE__ */ new Map();
-        if (typeof size === "object" && bytes.slice(offset).length === 0) {
-          return [map, offset];
-        }
-        const [resolvedSize, newOffset] = decodeArrayLikeCodecSize(
-          size,
-          [key.fixedSize, value.fixedSize],
-          bytes,
-          offset
-        );
-        offset = newOffset;
-        for (let i = 0; i < resolvedSize; i += 1) {
-          const [decodedKey, kOffset] = key.decode(bytes, offset);
-          offset = kOffset;
-          const [decodedValue, vOffset] = value.decode(bytes, offset);
-          offset = vOffset;
-          map.set(decodedKey, decodedValue);
-        }
-        return [map, offset];
+  function getTupleDecoder(items) {
+    var _a;
+    const fixedSize = sumCodecSizes(items.map(getFixedSize));
+    const maxSize = (_a = sumCodecSizes(items.map(getMaxSize))) != null ? _a : void 0;
+    return createDecoder({
+      ...fixedSize === null ? { maxSize } : { fixedSize },
+      read: (bytes, offset) => {
+        const values = [];
+        items.forEach((item) => {
+          const [newValue, newOffset] = item.read(bytes, offset);
+          values.push(newValue);
+          offset = newOffset;
+        });
+        return [values, offset];
       }
-    };
+    });
+  }
+  function getTupleCodec(items) {
+    return combineCodec(
+      getTupleEncoder(items),
+      getTupleDecoder(items)
+    );
+  }
+
+  // src/map.ts
+  function getMapEncoder(key, value, config = {}) {
+    return mapEncoder(
+      getArrayEncoder(getTupleEncoder([key, value]), config),
+      (map) => [...map.entries()]
+    );
+  }
+  function getMapDecoder(key, value, config = {}) {
+    return mapDecoder(
+      getArrayDecoder(getTupleDecoder([key, value]), config),
+      (entries) => new Map(entries)
+    );
   }
-  function getMapCodec(key, value, options = {}) {
-    return combineCodec(getMapEncoder(key, value, options), getMapDecoder(key, value, options));
+  function getMapCodec(key, value, config = {}) {
+    return combineCodec(getMapEncoder(key, value, config), getMapDecoder(key, value, config));
   }
 
   // src/nullable.ts
-  function nullableCodecHelper(item, prefix, fixed, description) {
-    let descriptionSuffix = `; ${prefix.description}`;
-    let fixedSize = item.fixedSize === 0 ? prefix.fixedSize : null;
-    if (fixed) {
-      assertFixedSizeCodec(item, "Fixed nullables can only be used with fixed-size codecs.");
-      assertFixedSizeCodec(prefix, "Fixed nullables can only be used with fixed-size prefix.");
-      descriptionSuffix += "; fixed";
-      fixedSize = prefix.fixedSize + item.fixedSize;
+  function getNullableEncoder(item, config = {}) {
+    var _a, _b, _c;
+    const prefix = (_a = config.prefix) != null ? _a : getU8Encoder();
+    const fixed = (_b = config.fixed) != null ? _b : false;
+    const isZeroSizeItem = isFixedSize(item) && isFixedSize(prefix) && item.fixedSize === 0;
+    if (fixed || isZeroSizeItem) {
+      assertIsFixedSize(item, "Fixed nullables can only be used with fixed-size codecs.");
+      assertIsFixedSize(prefix, "Fixed nullables can only be used with fixed-size prefix.");
+      const fixedSize = prefix.fixedSize + item.fixedSize;
+      return createEncoder({
+        fixedSize,
+        write: (option, bytes, offset) => {
+          const prefixOffset = prefix.write(Number(option !== null), bytes, offset);
+          if (option !== null) {
+            item.write(option, bytes, prefixOffset);
+          }
+          return offset + fixedSize;
+        }
+      });
     }
-    return {
-      description: description ?? `nullable(${item.description + descriptionSuffix})`,
-      fixedSize,
-      maxSize: sumCodecSizes([prefix.maxSize, item.maxSize])
-    };
-  }
-  function getNullableEncoder(item, options = {}) {
-    const prefix = options.prefix ?? getU8Encoder();
-    const fixed = options.fixed ?? false;
-    return {
-      ...nullableCodecHelper(item, prefix, fixed, options.description),
-      encode: (option) => {
-        const prefixByte = prefix.encode(Number(option !== null));
-        let itemBytes = option !== null ? item.encode(option) : new Uint8Array();
-        itemBytes = fixed ? fixBytes(itemBytes, item.fixedSize) : itemBytes;
-        return mergeBytes([prefixByte, itemBytes]);
+    return createEncoder({
+      getSizeFromValue: (option) => getEncodedSize(Number(option !== null), prefix) + (option !== null ? getEncodedSize(option, item) : 0),
+      maxSize: (_c = sumCodecSizes([prefix, item].map(getMaxSize))) != null ? _c : void 0,
+      write: (option, bytes, offset) => {
+        offset = prefix.write(Number(option !== null), bytes, offset);
+        if (option !== null) {
+          offset = item.write(option, bytes, offset);
+        }
+        return offset;
       }
-    };
+    });
   }
-  function getNullableDecoder(item, options = {}) {
-    const prefix = options.prefix ?? getU8Decoder();
-    const fixed = options.fixed ?? false;
-    return {
-      ...nullableCodecHelper(item, prefix, fixed, options.description),
-      decode: (bytes, offset = 0) => {
+  function getNullableDecoder(item, config = {}) {
+    var _a, _b, _c;
+    const prefix = (_a = config.prefix) != null ? _a : getU8Decoder();
+    const fixed = (_b = config.fixed) != null ? _b : false;
+    let fixedSize = null;
+    const isZeroSizeItem = isFixedSize(item) && isFixedSize(prefix) && item.fixedSize === 0;
+    if (fixed || isZeroSizeItem) {
+      assertIsFixedSize(item, "Fixed nullables can only be used with fixed-size codecs.");
+      assertIsFixedSize(prefix, "Fixed nullables can only be used with fixed-size prefix.");
+      fixedSize = prefix.fixedSize + item.fixedSize;
+    }
+    return createDecoder({
+      ...fixedSize === null ? { maxSize: (_c = sumCodecSizes([prefix, item].map(getMaxSize))) != null ? _c : void 0 } : { fixedSize },
+      read: (bytes, offset) => {
         if (bytes.length - offset <= 0) {
           return [null, offset];
         }
-        const fixedOffset = offset + (prefix.fixedSize ?? 0) + (item.fixedSize ?? 0);
-        const [isSome, prefixOffset] = prefix.decode(bytes, offset);
-        offset = prefixOffset;
+        const [isSome, prefixOffset] = prefix.read(bytes, offset);
         if (isSome === 0) {
-          return [null, fixed ? fixedOffset : offset];
+          return [null, fixedSize !== null ? offset + fixedSize : prefixOffset];
         }
-        const [value, newOffset] = item.decode(bytes, offset);
-        offset = newOffset;
-        return [value, fixed ? fixedOffset : offset];
+        const [value, newOffset] = item.read(bytes, prefixOffset);
+        return [value, fixedSize !== null ? offset + fixedSize : newOffset];
       }
-    };
+    });
   }
-  function getNullableCodec(item, options = {}) {
-    return combineCodec(getNullableEncoder(item, options), getNullableDecoder(item, options));
+  function getNullableCodec(item, config = {}) {
+    const configCast = config;
+    return combineCodec(getNullableEncoder(item, configCast), getNullableDecoder(item, configCast));
   }
 
   // src/scalar-enum.ts
-  function scalarEnumCoderHelper(constructor, prefix, description) {
+  function getScalarEnumEncoder(constructor, config = {}) {
+    var _a;
+    const prefix = (_a = config.size) != null ? _a : getU8Encoder();
+    const { minRange, maxRange, stringValues, enumKeys, enumValues } = getScalarEnumStats(constructor);
+    return mapEncoder(prefix, (value) => {
+      const isInvalidNumber = typeof value === "number" && (value < minRange || value > maxRange);
+      const isInvalidString = typeof value === "string" && !stringValues.includes(value);
+      if (isInvalidNumber || isInvalidString) {
+        throw new Error(
+          `Invalid scalar enum variant. Expected one of [${stringValues.join(", ")}] or a number between ${minRange} and ${maxRange}, got "${value}".`
+        );
+      }
+      if (typeof value === "number")
+        return value;
+      const valueIndex = enumValues.indexOf(value);
+      if (valueIndex >= 0)
+        return valueIndex;
+      return enumKeys.indexOf(value);
+    });
+  }
+  function getScalarEnumDecoder(constructor, config = {}) {
+    var _a;
+    const prefix = (_a = config.size) != null ? _a : getU8Decoder();
+    const { minRange, maxRange, isNumericEnum, enumValues } = getScalarEnumStats(constructor);
+    return mapDecoder(prefix, (value) => {
+      const valueAsNumber = Number(value);
+      if (valueAsNumber < minRange || valueAsNumber > maxRange) {
+        throw new Error(
+          `Enum discriminator out of range. Expected a number between ${minRange} and ${maxRange}, got ${valueAsNumber}.`
+        );
+      }
+      return isNumericEnum ? valueAsNumber : enumValues[valueAsNumber];
+    });
+  }
+  function getScalarEnumCodec(constructor, config = {}) {
+    return combineCodec(getScalarEnumEncoder(constructor, config), getScalarEnumDecoder(constructor, config));
+  }
+  function getScalarEnumStats(constructor) {
     const enumKeys = Object.keys(constructor);
     const enumValues = Object.values(constructor);
     const isNumericEnum = enumValues.some((v) => typeof v === "number");
-    const valueDescriptions = enumValues.filter((v) => typeof v === "string").join(", ");
     const minRange = 0;
     const maxRange = isNumericEnum ? enumValues.length / 2 - 1 : enumValues.length - 1;
     const stringValues = isNumericEnum ? [...enumKeys] : [.../* @__PURE__ */ new Set([...enumKeys, ...enumValues])];
     return {
-      description: description ?? `enum(${valueDescriptions}; ${prefix.description})`,
       enumKeys,
       enumValues,
-      fixedSize: prefix.fixedSize,
       isNumericEnum,
       maxRange,
-      maxSize: prefix.maxSize,
       minRange,
       stringValues
     };
   }
-  function getScalarEnumEncoder(constructor, options = {}) {
-    const prefix = options.size ?? getU8Encoder();
-    const { description, fixedSize, maxSize, minRange, maxRange, stringValues, enumKeys, enumValues } = scalarEnumCoderHelper(constructor, prefix, options.description);
-    return {
-      description,
-      encode: (value) => {
-        const isInvalidNumber = typeof value === "number" && (value < minRange || value > maxRange);
-        const isInvalidString = typeof value === "string" && !stringValues.includes(value);
-        if (isInvalidNumber || isInvalidString) {
-          throw new Error(
-            `Invalid scalar enum variant. Expected one of [${stringValues.join(", ")}] or a number between ${minRange} and ${maxRange}, got "${value}".`
-          );
-        }
-        if (typeof value === "number")
-          return prefix.encode(value);
-        const valueIndex = enumValues.indexOf(value);
-        if (valueIndex >= 0)
-          return prefix.encode(valueIndex);
-        return prefix.encode(enumKeys.indexOf(value));
-      },
-      fixedSize,
-      maxSize
-    };
-  }
-  function getScalarEnumDecoder(constructor, options = {}) {
-    const prefix = options.size ?? getU8Decoder();
-    const { description, fixedSize, maxSize, minRange, maxRange, isNumericEnum, enumValues } = scalarEnumCoderHelper(
-      constructor,
-      prefix,
-      options.description
-    );
-    return {
-      decode: (bytes, offset = 0) => {
-        assertByteArrayIsNotEmptyForCodec("enum", bytes, offset);
-        const [value, newOffset] = prefix.decode(bytes, offset);
-        const valueAsNumber = Number(value);
-        offset = newOffset;
-        if (valueAsNumber < minRange || valueAsNumber > maxRange) {
-          throw new Error(
-            `Enum discriminator out of range. Expected a number between ${minRange} and ${maxRange}, got ${valueAsNumber}.`
-          );
-        }
-        return [isNumericEnum ? valueAsNumber : enumValues[valueAsNumber], offset];
-      },
-      description,
-      fixedSize,
-      maxSize
-    };
-  }
-  function getScalarEnumCodec(constructor, options = {}) {
-    return combineCodec(getScalarEnumEncoder(constructor, options), getScalarEnumDecoder(constructor, options));
-  }
 
   // src/set.ts
-  function setCodecHelper(item, size, description) {
-    if (size === "remainder" && item.fixedSize === null) {
-      throw new Error('Codecs of "remainder" size must have fixed-size items.');
-    }
-    return {
-      description: description ?? `set(${item.description}; ${getArrayLikeCodecSizeDescription(size)})`,
-      fixedSize: getArrayLikeCodecSizeFromChildren(size, [item.fixedSize]),
-      maxSize: getArrayLikeCodecSizeFromChildren(size, [item.maxSize])
-    };
+  function getSetEncoder(item, config = {}) {
+    return mapEncoder(getArrayEncoder(item, config), (set) => [...set]);
   }
-  function getSetEncoder(item, options = {}) {
-    const size = options.size ?? getU32Encoder();
-    return {
-      ...setCodecHelper(item, size, options.description),
-      encode: (set) => {
-        if (typeof size === "number" && set.size !== size) {
-          assertValidNumberOfItemsForCodec("set", size, set.size);
-        }
-        const itemBytes = Array.from(set, (value) => item.encode(value));
-        return mergeBytes([getArrayLikeCodecSizePrefix(size, set.size), ...itemBytes]);
-      }
-    };
+  function getSetDecoder(item, config = {}) {
+    return mapDecoder(getArrayDecoder(item, config), (entries) => new Set(entries));
   }
-  function getSetDecoder(item, options = {}) {
-    const size = options.size ?? getU32Decoder();
-    return {
-      ...setCodecHelper(item, size, options.description),
-      decode: (bytes, offset = 0) => {
-        const set = /* @__PURE__ */ new Set();
-        if (typeof size === "object" && bytes.slice(offset).length === 0) {
-          return [set, offset];
-        }
-        const [resolvedSize, newOffset] = decodeArrayLikeCodecSize(size, [item.fixedSize], bytes, offset);
-        offset = newOffset;
-        for (let i = 0; i < resolvedSize; i += 1) {
-          const [value, newOffset2] = item.decode(bytes, offset);
-          offset = newOffset2;
-          set.add(value);
-        }
-        return [set, offset];
-      }
-    };
-  }
-  function getSetCodec(item, options = {}) {
-    return combineCodec(getSetEncoder(item, options), getSetDecoder(item, options));
+  function getSetCodec(item, config = {}) {
+    return combineCodec(getSetEncoder(item, config), getSetDecoder(item, config));
   }
 
   // src/struct.ts
-  function structCodecHelper(fields, description) {
-    const fieldDescriptions = fields.map(([name, codec]) => `${String(name)}: ${codec.description}`).join(", ");
-    return {
-      description: description ?? `struct(${fieldDescriptions})`,
-      fixedSize: sumCodecSizes(fields.map(([, field]) => field.fixedSize)),
-      maxSize: sumCodecSizes(fields.map(([, field]) => field.maxSize))
-    };
-  }
-  function getStructEncoder(fields, options = {}) {
-    return {
-      ...structCodecHelper(fields, options.description),
-      encode: (struct) => {
-        const fieldBytes = fields.map(([key, codec]) => codec.encode(struct[key]));
-        return mergeBytes(fieldBytes);
+  function getStructEncoder(fields) {
+    var _a;
+    const fieldCodecs = fields.map(([, codec]) => codec);
+    const fixedSize = sumCodecSizes(fieldCodecs.map(getFixedSize));
+    const maxSize = (_a = sumCodecSizes(fieldCodecs.map(getMaxSize))) != null ? _a : void 0;
+    return createEncoder({
+      ...fixedSize === null ? {
+        getSizeFromValue: (value) => fields.map(([key, codec]) => getEncodedSize(value[key], codec)).reduce((all, one) => all + one, 0),
+        maxSize
+      } : { fixedSize },
+      write: (struct, bytes, offset) => {
+        fields.forEach(([key, codec]) => {
+          offset = codec.write(struct[key], bytes, offset);
+        });
+        return offset;
       }
-    };
+    });
   }
-  function getStructDecoder(fields, options = {}) {
-    return {
-      ...structCodecHelper(fields, options.description),
-      decode: (bytes, offset = 0) => {
+  function getStructDecoder(fields) {
+    var _a;
+    const fieldCodecs = fields.map(([, codec]) => codec);
+    const fixedSize = sumCodecSizes(fieldCodecs.map(getFixedSize));
+    const maxSize = (_a = sumCodecSizes(fieldCodecs.map(getMaxSize))) != null ? _a : void 0;
+    return createDecoder({
+      ...fixedSize === null ? { maxSize } : { fixedSize },
+      read: (bytes, offset) => {
         const struct = {};
         fields.forEach(([key, codec]) => {
-          const [value, newOffset] = codec.decode(bytes, offset);
+          const [value, newOffset] = codec.read(bytes, offset);
           offset = newOffset;
           struct[key] = value;
         });
         return [struct, offset];
       }
-    };
-  }
-  function getStructCodec(fields, options = {}) {
-    return combineCodec(getStructEncoder(fields, options), getStructDecoder(fields, options));
-  }
-
-  // src/tuple.ts
-  function tupleCodecHelper(items, description) {
-    const itemDescriptions = items.map((item) => item.description).join(", ");
-    return {
-      description: description ?? `tuple(${itemDescriptions})`,
-      fixedSize: sumCodecSizes(items.map((item) => item.fixedSize)),
-      maxSize: sumCodecSizes(items.map((item) => item.maxSize))
-    };
-  }
-  function getTupleEncoder(items, options = {}) {
-    return {
-      ...tupleCodecHelper(items, options.description),
-      encode: (value) => {
-        assertValidNumberOfItemsForCodec("tuple", items.length, value.length);
-        return mergeBytes(items.map((item, index) => item.encode(value[index])));
-      }
-    };
-  }
-  function getTupleDecoder(items, options = {}) {
-    return {
-      ...tupleCodecHelper(items, options.description),
-      decode: (bytes, offset = 0) => {
-        const values = [];
-        items.forEach((codec) => {
-          const [newValue, newOffset] = codec.decode(bytes, offset);
-          values.push(newValue);
-          offset = newOffset;
-        });
-        return [values, offset];
-      }
-    };
+    });
   }
-  function getTupleCodec(items, options = {}) {
-    return combineCodec(
-      getTupleEncoder(items, options),
-      getTupleDecoder(items, options)
-    );
+  function getStructCodec(fields) {
+    return combineCodec(getStructEncoder(fields), getStructDecoder(fields));
   }
 
   // src/unit.ts
-  function getUnitEncoder(options = {}) {
-    return {
-      description: options.description ?? "unit",
-      encode: () => new Uint8Array(),
+  function getUnitEncoder() {
+    return createEncoder({
       fixedSize: 0,
-      maxSize: 0
-    };
+      write: (_value, _bytes, offset) => offset
+    });
   }
-  function getUnitDecoder(options = {}) {
-    return {
-      decode: (_bytes, offset = 0) => [void 0, offset],
-      description: options.description ?? "unit",
+  function getUnitDecoder() {
+    return createDecoder({
       fixedSize: 0,
-      maxSize: 0
-    };
+      read: (_bytes, offset) => [void 0, offset]
+    });
   }
-  function getUnitCodec(options = {}) {
-    return combineCodec(getUnitEncoder(options), getUnitDecoder(options));
+  function getUnitCodec() {
+    return combineCodec(getUnitEncoder(), getUnitDecoder());
   }
 
   exports.assertValidNumberOfItemsForCodec = assertValidNumberOfItemsForCodec;
-  exports.decodeArrayLikeCodecSize = decodeArrayLikeCodecSize;
   exports.getArrayCodec = getArrayCodec;
   exports.getArrayDecoder = getArrayDecoder;
   exports.getArrayEncoder = getArrayEncoder;
-  exports.getArrayLikeCodecSizeDescription = getArrayLikeCodecSizeDescription;
-  exports.getArrayLikeCodecSizeFromChildren = getArrayLikeCodecSizeFromChildren;
-  exports.getArrayLikeCodecSizePrefix = getArrayLikeCodecSizePrefix;
   exports.getBitArrayCodec = getBitArrayCodec;
   exports.getBitArrayDecoder = getBitArrayDecoder;
   exports.getBitArrayEncoder = getBitArrayEncoder;