@solana/codecs-data-structures 2.0.0-experimental.efe6f4d → 2.0.0-experimental.f2a2e5b

package/dist/index.native.js

@@ -1,9 +1,14 @@
-import { mergeBytes, combineCodec, assertByteArrayHasEnoughBytesForCodec, assertFixedSizeCodec, assertByteArrayIsNotEmptyForCodec, fixEncoder, fixDecoder, fixBytes } from '@solana/codecs-core';
+import { createEncoder, getEncodedSize, createDecoder, combineCodec, assertByteArrayHasEnoughBytesForCodec, assertIsFixedSize, mapEncoder, mapDecoder, fixEncoder, fixDecoder, assertByteArrayIsNotEmptyForCodec, isFixedSize } from '@solana/codecs-core';
 import { getU32Encoder, getU32Decoder, getU8Encoder, getU8Decoder } from '@solana/codecs-numbers';
 
 // src/array.ts
 
-// src/utils.ts
+// src/assertions.ts
+function assertValidNumberOfItemsForCodec(codecDescription, expected, actual) {
+  if (expected !== actual) {
+    throw new Error(`Expected [${codecDescription}] to have ${expected} items, got ${actual}.`);
+  }
+}
 function maxCodecSizes(sizes) {
   return sizes.reduce(
     (all, size) => all === null || size === null ? null : Math.max(all, size),
@@ -13,106 +18,88 @@ function maxCodecSizes(sizes) {
 function sumCodecSizes(sizes) {
   return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
 }
-
-// src/array-like-codec-size.ts
-function decodeArrayLikeCodecSize(size, childrenSizes, bytes, offset) {
-  if (typeof size === "number") {
-    return [size, offset];
-  }
-  if (typeof size === "object") {
-    return size.decode(bytes, offset);
-  }
-  if (size === "remainder") {
-    const childrenSize = sumCodecSizes(childrenSizes);
-    if (childrenSize === null) {
-      throw new Error('Codecs of "remainder" size must have fixed-size items.');
-    }
-    const remainder = bytes.slice(offset).length;
-    if (remainder % childrenSize !== 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.`
-      );
-    }
-    return [remainder / childrenSize, offset];
-  }
-  throw new Error(`Unrecognized array-like codec size: ${JSON.stringify(size)}`);
+function getFixedSize(codec) {
+  return isFixedSize(codec) ? codec.fixedSize : null;
 }
-function getArrayLikeCodecSizeDescription(size) {
-  return typeof size === "object" ? size.description : `${size}`;
-}
-function getArrayLikeCodecSizeFromChildren(size, childrenSizes) {
-  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}.`);
-  }
+function getMaxSize(codec) {
+  return isFixedSize(codec) ? codec.fixedSize : codec.maxSize ?? null;
 }
 
 // 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, config = {}) {
   const size = config.size ?? getU32Encoder();
-  return {
-    ...arrayCodecHelper(item, size, config.description),
-    encode: (value) => {
+  const fixedSize = computeArrayLikeCodecSize(size, getFixedSize(item));
+  const maxSize = computeArrayLikeCodecSize(size, getMaxSize(item)) ?? 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, value.length);
+        assertValidNumberOfItemsForCodec("array", size, array.length);
+      }
+      if (typeof size === "object") {
+        offset = size.write(array.length, bytes, offset);
       }
-      return mergeBytes([getArrayLikeCodecSizePrefix(size, value.length), ...value.map((v) => item.encode(v))]);
+      array.forEach((value) => {
+        offset = item.write(value, bytes, offset);
+      });
+      return offset;
     }
-  };
+  });
 }
 function getArrayDecoder(item, config = {}) {
   const size = config.size ?? getU32Decoder();
-  return {
-    ...arrayCodecHelper(item, size, config.description),
-    decode: (bytes, offset = 0) => {
+  const itemSize = getFixedSize(item);
+  const fixedSize = computeArrayLikeCodecSize(size, itemSize);
+  const maxSize = computeArrayLikeCodecSize(size, getMaxSize(item)) ?? void 0;
+  return createDecoder({
+    ...fixedSize !== null ? { fixedSize } : { maxSize },
+    read: (bytes, offset) => {
+      const array = [];
       if (typeof size === "object" && bytes.slice(offset).length === 0) {
-        return [[], offset];
+        return [array, offset];
+      }
+      if (size === "remainder") {
+        while (offset < bytes.length) {
+          const [value, newOffset2] = item.read(bytes, offset);
+          offset = newOffset2;
+          array.push(value);
+        }
+        return [array, offset];
       }
-      const [resolvedSize, newOffset] = decodeArrayLikeCodecSize(size, [item.fixedSize], bytes, offset);
+      const [resolvedSize, newOffset] = typeof size === "number" ? [size, offset] : size.read(bytes, offset);
       offset = newOffset;
-      const values = [];
       for (let i = 0; i < resolvedSize; i += 1) {
-        const [value, newOffset2] = item.decode(bytes, offset);
-        values.push(value);
+        const [value, newOffset2] = item.read(bytes, offset);
         offset = newOffset2;
+        array.push(value);
       }
-      return [values, offset];
+      return [array, offset];
     }
-  };
+  });
 }
 function getArrayCodec(item, config = {}) {
   return combineCodec(getArrayEncoder(item, config), getArrayDecoder(item, config));
 }
-var getBitArrayEncoder = (size, config = {}) => {
+function computeArrayLikeCodecSize(size, itemSize) {
+  if (typeof size !== "number")
+    return null;
+  if (size === 0)
+    return 0;
+  return itemSize === null ? null : itemSize * size;
+}
+function getBitArrayEncoder(size, config = {}) {
   const parsedConfig = typeof config === "boolean" ? { backward: config } : config;
   const backward = parsedConfig.backward ?? false;
-  const backwardSuffix = backward ? "; backward" : "";
-  return {
-    description: parsedConfig.description ?? `bitArray(${size}${backwardSuffix})`,
-    encode(value) {
-      const bytes = [];
+  return createEncoder({
+    fixedSize: size,
+    write(value, bytes, offset) {
+      const bytesToAdd = [];
       for (let i = 0; i < size; i += 1) {
         let byte = 0;
         for (let j = 0; j < 8; j += 1) {
@@ -120,23 +107,22 @@ var getBitArrayEncoder = (size, config = {}) => {
           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);
-    },
-    fixedSize: size,
-    maxSize: size
-  };
-};
-var getBitArrayDecoder = (size, config = {}) => {
+      bytes.set(bytesToAdd, offset);
+      return size;
+    }
+  });
+}
+function getBitArrayDecoder(size, config = {}) {
   const parsedConfig = typeof config === "boolean" ? { backward: config } : config;
   const backward = parsedConfig.backward ?? false;
-  const backwardSuffix = backward ? "; backward" : "";
-  return {
-    decode(bytes, offset = 0) {
+  return createDecoder({
+    fixedSize: size,
+    read(bytes, offset) {
       assertByteArrayHasEnoughBytesForCodec("bitArray", size, bytes, offset);
       const booleans = [];
       let slice = bytes.slice(offset, offset + size);
@@ -153,138 +139,107 @@ var getBitArrayDecoder = (size, config = {}) => {
         }
       });
       return [booleans, offset + size];
-    },
-    description: parsedConfig.description ?? `bitArray(${size}${backwardSuffix})`,
-    fixedSize: size,
-    maxSize: size
-  };
-};
-var getBitArrayCodec = (size, config = {}) => combineCodec(getBitArrayEncoder(size, config), getBitArrayDecoder(size, config));
+    }
+  });
+}
+function getBitArrayCodec(size, config = {}) {
+  return combineCodec(getBitArrayEncoder(size, config), getBitArrayDecoder(size, config));
+}
 function getBooleanEncoder(config = {}) {
   const size = config.size ?? getU8Encoder();
-  assertFixedSizeCodec(size, "Codec [bool] requires a fixed size.");
-  return {
-    description: config.description ?? `bool(${size.description})`,
-    encode: (value) => size.encode(value ? 1 : 0),
-    fixedSize: size.fixedSize,
-    maxSize: size.fixedSize
-  };
+  assertIsFixedSize(size, "Codec [bool] requires a fixed size.");
+  return mapEncoder(size, (value) => value ? 1 : 0);
 }
 function getBooleanDecoder(config = {}) {
   const size = config.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: config.description ?? `bool(${size.description})`,
-    fixedSize: size.fixedSize,
-    maxSize: size.fixedSize
-  };
+  assertIsFixedSize(size, "Codec [bool] requires a fixed size.");
+  return mapDecoder(size, (value) => Number(value) === 1);
 }
 function getBooleanCodec(config = {}) {
   return combineCodec(getBooleanEncoder(config), getBooleanDecoder(config));
 }
 function getBytesEncoder(config = {}) {
   const size = config.size ?? "variable";
-  const sizeDescription = typeof size === "object" ? size.description : `${size}`;
-  const description = config.description ?? `bytes(${sizeDescription})`;
-  const byteEncoder = {
-    description,
-    encode: (value) => value,
-    fixedSize: null,
-    maxSize: null
-  };
+  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(config = {}) {
   const size = config.size ?? "variable";
-  const sizeDescription = typeof size === "object" ? size.description : `${size}`;
-  const description = config.description ?? `bytes(${sizeDescription})`;
-  const byteDecoder = {
-    decode: (bytes, offset = 0) => {
+  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(config = {}) {
   return combineCodec(getBytesEncoder(config), getBytesDecoder(config));
 }
-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, config = {}) {
   const prefix = config.size ?? getU8Encoder();
-  return {
-    ...dataEnumCodecHelper(variants, prefix, config.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]);
+  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, config = {}) {
   const prefix = config.size ?? getU8Decoder();
-  return {
-    ...dataEnumCodecHelper(variants, prefix, config.description),
-    decode: (bytes, offset = 0) => {
+  const fixedSize = getDataEnumFixedSize(variants, prefix);
+  return createDecoder({
+    ...fixedSize !== null ? { fixedSize } : { maxSize: getDataEnumMaxSize(variants, prefix) },
+    read: (bytes, offset) => {
       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;
       if (!variantField) {
@@ -292,329 +247,270 @@ function getDataEnumDecoder(variants, config = {}) {
           `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];
     }
-  };
+  });
 }
 function getDataEnumCodec(variants, config = {}) {
   return combineCodec(getDataEnumEncoder(variants, config), getDataEnumDecoder(variants, config));
 }
-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) {
+  const maxVariantSize = maxCodecSizes(variants.map(([, codec]) => getMaxSize(codec)));
+  return sumCodecSizes([getMaxSize(prefix), maxVariantSize]) ?? 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 getTupleEncoder(items) {
+  const fixedSize = sumCodecSizes(items.map(getFixedSize));
+  const maxSize = sumCodecSizes(items.map(getMaxSize)) ?? 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 getTupleDecoder(items) {
+  const fixedSize = sumCodecSizes(items.map(getFixedSize));
+  const maxSize = sumCodecSizes(items.map(getMaxSize)) ?? 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 = {}) {
-  const size = config.size ?? getU32Encoder();
-  return {
-    ...mapCodecHelper(key, value, size, config.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]);
-    }
-  };
+  return mapEncoder(
+    getArrayEncoder(getTupleEncoder([key, value]), config),
+    (map) => [...map.entries()]
+  );
 }
 function getMapDecoder(key, value, config = {}) {
-  const size = config.size ?? getU32Decoder();
-  return {
-    ...mapCodecHelper(key, value, size, config.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];
-    }
-  };
+  return mapDecoder(
+    getArrayDecoder(getTupleDecoder([key, value]), config),
+    (entries) => new Map(entries)
+  );
 }
 function getMapCodec(key, value, config = {}) {
   return combineCodec(getMapEncoder(key, value, config), getMapDecoder(key, value, config));
 }
-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;
-  }
-  return {
-    description: description ?? `nullable(${item.description + descriptionSuffix})`,
-    fixedSize,
-    maxSize: sumCodecSizes([prefix.maxSize, item.maxSize])
-  };
-}
 function getNullableEncoder(item, config = {}) {
   const prefix = config.prefix ?? getU8Encoder();
   const fixed = config.fixed ?? false;
-  return {
-    ...nullableCodecHelper(item, prefix, fixed, config.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]);
+  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 createEncoder({
+    getSizeFromValue: (option) => getEncodedSize(Number(option !== null), prefix) + (option !== null ? getEncodedSize(option, item) : 0),
+    maxSize: sumCodecSizes([prefix, item].map(getMaxSize)) ?? 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, config = {}) {
   const prefix = config.prefix ?? getU8Decoder();
   const fixed = config.fixed ?? false;
-  return {
-    ...nullableCodecHelper(item, prefix, fixed, config.description),
-    decode: (bytes, offset = 0) => {
+  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: sumCodecSizes([prefix, item].map(getMaxSize)) ?? 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, config = {}) {
-  return combineCodec(getNullableEncoder(item, config), getNullableDecoder(item, config));
+  const configCast = config;
+  return combineCodec(getNullableEncoder(item, configCast), getNullableDecoder(item, configCast));
+}
+function getScalarEnumEncoder(constructor, config = {}) {
+  const prefix = config.size ?? 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 = {}) {
+  const prefix = config.size ?? 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 scalarEnumCoderHelper(constructor, prefix, description) {
+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, config = {}) {
-  const prefix = config.size ?? getU8Encoder();
-  const { description, fixedSize, maxSize, minRange, maxRange, stringValues, enumKeys, enumValues } = scalarEnumCoderHelper(constructor, prefix, config.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, config = {}) {
-  const prefix = config.size ?? getU8Decoder();
-  const { description, fixedSize, maxSize, minRange, maxRange, isNumericEnum, enumValues } = scalarEnumCoderHelper(
-    constructor,
-    prefix,
-    config.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, config = {}) {
-  return combineCodec(getScalarEnumEncoder(constructor, config), getScalarEnumDecoder(constructor, config));
-}
-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 = {}) {
-  const size = config.size ?? getU32Encoder();
-  return {
-    ...setCodecHelper(item, size, config.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]);
-    }
-  };
+  return mapEncoder(getArrayEncoder(item, config), (set) => [...set]);
 }
 function getSetDecoder(item, config = {}) {
-  const size = config.size ?? getU32Decoder();
-  return {
-    ...setCodecHelper(item, size, config.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];
-    }
-  };
+  return mapDecoder(getArrayDecoder(item, config), (entries) => new Set(entries));
 }
 function getSetCodec(item, config = {}) {
   return combineCodec(getSetEncoder(item, config), getSetDecoder(item, config));
 }
-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, config = {}) {
-  return {
-    ...structCodecHelper(fields, config.description),
-    encode: (struct) => {
-      const fieldBytes = fields.map(([key, codec]) => codec.encode(struct[key]));
-      return mergeBytes(fieldBytes);
+function getStructEncoder(fields) {
+  const fieldCodecs = fields.map(([, codec]) => codec);
+  const fixedSize = sumCodecSizes(fieldCodecs.map(getFixedSize));
+  const maxSize = sumCodecSizes(fieldCodecs.map(getMaxSize)) ?? 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, config = {}) {
-  return {
-    ...structCodecHelper(fields, config.description),
-    decode: (bytes, offset = 0) => {
+  });
+}
+function getStructDecoder(fields) {
+  const fieldCodecs = fields.map(([, codec]) => codec);
+  const fixedSize = sumCodecSizes(fieldCodecs.map(getFixedSize));
+  const maxSize = sumCodecSizes(fieldCodecs.map(getMaxSize)) ?? 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, config = {}) {
-  return combineCodec(getStructEncoder(fields, config), getStructDecoder(fields, config));
-}
-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, config = {}) {
-  return {
-    ...tupleCodecHelper(items, config.description),
-    encode: (value) => {
-      assertValidNumberOfItemsForCodec("tuple", items.length, value.length);
-      return mergeBytes(items.map((item, index) => item.encode(value[index])));
-    }
-  };
-}
-function getTupleDecoder(items, config = {}) {
-  return {
-    ...tupleCodecHelper(items, config.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, config = {}) {
-  return combineCodec(
-    getTupleEncoder(items, config),
-    getTupleDecoder(items, config)
-  );
+function getStructCodec(fields) {
+  return combineCodec(getStructEncoder(fields), getStructDecoder(fields));
 }
-function getUnitEncoder(config = {}) {
-  return {
-    description: config.description ?? "unit",
-    encode: () => new Uint8Array(),
+function getUnitEncoder() {
+  return createEncoder({
     fixedSize: 0,
-    maxSize: 0
-  };
+    write: (_value, _bytes, offset) => offset
+  });
 }
-function getUnitDecoder(config = {}) {
-  return {
-    decode: (_bytes, offset = 0) => [void 0, offset],
-    description: config.description ?? "unit",
+function getUnitDecoder() {
+  return createDecoder({
     fixedSize: 0,
-    maxSize: 0
-  };
+    read: (_bytes, offset) => [void 0, offset]
+  });
 }
-function getUnitCodec(config = {}) {
-  return combineCodec(getUnitEncoder(config), getUnitDecoder(config));
+function getUnitCodec() {
+  return combineCodec(getUnitEncoder(), getUnitDecoder());
 }
 
-export { assertValidNumberOfItemsForCodec, decodeArrayLikeCodecSize, getArrayCodec, getArrayDecoder, getArrayEncoder, getArrayLikeCodecSizeDescription, getArrayLikeCodecSizeFromChildren, getArrayLikeCodecSizePrefix, getBitArrayCodec, getBitArrayDecoder, getBitArrayEncoder, getBooleanCodec, getBooleanDecoder, getBooleanEncoder, getBytesCodec, getBytesDecoder, getBytesEncoder, getDataEnumCodec, getDataEnumDecoder, getDataEnumEncoder, getMapCodec, getMapDecoder, getMapEncoder, getNullableCodec, getNullableDecoder, getNullableEncoder, getScalarEnumCodec, getScalarEnumDecoder, getScalarEnumEncoder, getSetCodec, getSetDecoder, getSetEncoder, getStructCodec, getStructDecoder, getStructEncoder, getTupleCodec, getTupleDecoder, getTupleEncoder, getUnitCodec, getUnitDecoder, getUnitEncoder };
+export { assertValidNumberOfItemsForCodec, getArrayCodec, getArrayDecoder, getArrayEncoder, getBitArrayCodec, getBitArrayDecoder, getBitArrayEncoder, getBooleanCodec, getBooleanDecoder, getBooleanEncoder, getBytesCodec, getBytesDecoder, getBytesEncoder, getDataEnumCodec, getDataEnumDecoder, getDataEnumEncoder, getMapCodec, getMapDecoder, getMapEncoder, getNullableCodec, getNullableDecoder, getNullableEncoder, getScalarEnumCodec, getScalarEnumDecoder, getScalarEnumEncoder, getSetCodec, getSetDecoder, getSetEncoder, getStructCodec, getStructDecoder, getStructEncoder, getTupleCodec, getTupleDecoder, getTupleEncoder, getUnitCodec, getUnitDecoder, getUnitEncoder };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.native.js.map