@solana/codecs-data-structures 2.0.0-experimental.5586a1b → 2.0.0-experimental.58ab189

package/dist/index.browser.cjs

@@ -5,7 +5,12 @@ var codecsNumbers = require('@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),
@@ -15,106 +20,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 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 getFixedSize(codec) {
+  return codecsCore.isFixedSize(codec) ? codec.fixedSize : null;
 }
-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 codecsCore.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, options = {}) {
-  const size = options.size ?? codecsNumbers.getU32Encoder();
-  return {
-    ...arrayCodecHelper(item, size, options.description),
-    encode: (value) => {
+function getArrayEncoder(item, config = {}) {
+  const size = config.size ?? codecsNumbers.getU32Encoder();
+  const fixedSize = computeArrayLikeCodecSize(size, getFixedSize(item));
+  const maxSize = computeArrayLikeCodecSize(size, getMaxSize(item)) ?? void 0;
+  return codecsCore.createEncoder({
+    ...fixedSize !== null ? { fixedSize } : {
+      getSizeFromValue: (array) => {
+        const prefixSize = typeof size === "object" ? codecsCore.getEncodedSize(array.length, size) : 0;
+        return prefixSize + [...array].reduce((all, value) => all + codecsCore.getEncodedSize(value, item), 0);
+      },
+      maxSize
+    },
+    write: (array, bytes, offset) => {
       if (typeof size === "number") {
-        assertValidNumberOfItemsForCodec("array", size, value.length);
+        assertValidNumberOfItemsForCodec("array", size, array.length);
       }
-      return codecsCore.mergeBytes([getArrayLikeCodecSizePrefix(size, value.length), ...value.map((v) => item.encode(v))]);
+      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, options = {}) {
-  const size = options.size ?? codecsNumbers.getU32Decoder();
-  return {
-    ...arrayCodecHelper(item, size, options.description),
-    decode: (bytes, offset = 0) => {
+  });
+}
+function getArrayDecoder(item, config = {}) {
+  const size = config.size ?? codecsNumbers.getU32Decoder();
+  const itemSize = getFixedSize(item);
+  const fixedSize = computeArrayLikeCodecSize(size, itemSize);
+  const maxSize = computeArrayLikeCodecSize(size, getMaxSize(item)) ?? void 0;
+  return codecsCore.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, options = {}) {
-  return codecsCore.combineCodec(getArrayEncoder(item, options), getArrayDecoder(item, options));
+function getArrayCodec(item, config = {}) {
+  return codecsCore.combineCodec(getArrayEncoder(item, config), getArrayDecoder(item, config));
 }
-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 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;
+  return codecsCore.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) {
@@ -122,23 +109,22 @@ var getBitArrayEncoder = (size, options = {}) => {
           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 = {}) {
+  const parsedConfig = typeof config === "boolean" ? { backward: config } : config;
+  const backward = parsedConfig.backward ?? false;
+  return codecsCore.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) {
       codecsCore.assertByteArrayHasEnoughBytesForCodec("bitArray", size, bytes, offset);
       const booleans = [];
       let slice = bytes.slice(offset, offset + size);
@@ -155,138 +141,115 @@ var getBitArrayDecoder = (size, options = {}) => {
         }
       });
       return [booleans, offset + size];
-    },
-    description: parsedOptions.description ?? `bitArray(${size}${backwardSuffix})`,
-    fixedSize: size,
-    maxSize: size
-  };
-};
-var getBitArrayCodec = (size, options = {}) => codecsCore.combineCodec(getBitArrayEncoder(size, options), getBitArrayDecoder(size, options));
-function getBooleanEncoder(options = {}) {
-  const size = options.size ?? codecsNumbers.getU8Encoder();
-  codecsCore.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 getBooleanDecoder(options = {}) {
-  const size = options.size ?? codecsNumbers.getU8Decoder();
-  codecsCore.assertFixedSizeCodec(size, "Codec [bool] requires a fixed size.");
-  return {
-    decode: (bytes, offset = 0) => {
-      codecsCore.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 getBitArrayCodec(size, config = {}) {
+  return codecsCore.combineCodec(getBitArrayEncoder(size, config), getBitArrayDecoder(size, config));
 }
-function getBooleanCodec(options = {}) {
-  return codecsCore.combineCodec(getBooleanEncoder(options), getBooleanDecoder(options));
-}
-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 getBooleanEncoder(config = {}) {
+  const size = config.size ?? codecsNumbers.getU8Encoder();
+  try {
+    codecsCore.assertIsFixedSize(size);
+  } catch (e) {
+    throw new Error("Codec [bool] requires a fixed size.");
+  }
+  return codecsCore.mapEncoder(size, (value) => value ? 1 : 0);
+}
+function getBooleanDecoder(config = {}) {
+  const size = config.size ?? codecsNumbers.getU8Decoder();
+  try {
+    codecsCore.assertIsFixedSize(size);
+  } catch (e) {
+    throw new Error("Codec [bool] requires a fixed size.");
+  }
+  return codecsCore.mapDecoder(size, (value) => Number(value) === 1);
+}
+function getBooleanCodec(config = {}) {
+  return codecsCore.combineCodec(getBooleanEncoder(config), getBooleanDecoder(config));
+}
+function getBytesEncoder(config = {}) {
+  const size = config.size ?? "variable";
+  const byteEncoder = codecsCore.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 codecsCore.fixEncoder(byteEncoder, size, description);
+    return codecsCore.fixEncoder(byteEncoder, size);
   }
-  return {
-    ...byteEncoder,
-    encode: (value) => {
-      const contentBytes = byteEncoder.encode(value);
-      const lengthBytes = size.encode(contentBytes.length);
-      return codecsCore.mergeBytes([lengthBytes, contentBytes]);
+  return codecsCore.createEncoder({
+    getSizeFromValue: (value) => codecsCore.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 = {}) {
+  const size = config.size ?? "variable";
+  const byteDecoder = codecsCore.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 codecsCore.fixDecoder(byteDecoder, size, description);
+    return codecsCore.fixDecoder(byteDecoder, size);
   }
-  return {
-    ...byteDecoder,
-    decode: (bytes, offset = 0) => {
+  return codecsCore.createDecoder({
+    read: (bytes, offset) => {
       codecsCore.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);
       codecsCore.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 codecsCore.combineCodec(getBytesEncoder(options), getBytesDecoder(options));
-}
-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 ?? codecsNumbers.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 codecsCore.mergeBytes([variantPrefix, variantBytes]);
+  });
+}
+function getBytesCodec(config = {}) {
+  return codecsCore.combineCodec(getBytesEncoder(config), getBytesDecoder(config));
+}
+function getDataEnumEncoder(variants, config = {}) {
+  const prefix = config.size ?? codecsNumbers.getU8Encoder();
+  const fixedSize = getDataEnumFixedSize(variants, prefix);
+  return codecsCore.createEncoder({
+    ...fixedSize !== null ? { fixedSize } : {
+      getSizeFromValue: (variant) => {
+        const discriminator = getVariantDiscriminator(variants, variant);
+        const variantEncoder = variants[discriminator][1];
+        return codecsCore.getEncodedSize(discriminator, prefix) + codecsCore.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 ?? codecsNumbers.getU8Decoder();
-  return {
-    ...dataEnumCodecHelper(variants, prefix, options.description),
-    decode: (bytes, offset = 0) => {
+  });
+}
+function getDataEnumDecoder(variants, config = {}) {
+  const prefix = config.size ?? codecsNumbers.getU8Decoder();
+  const fixedSize = getDataEnumFixedSize(variants, prefix);
+  return codecsCore.createDecoder({
+    ...fixedSize !== null ? { fixedSize } : { maxSize: getDataEnumMaxSize(variants, prefix) },
+    read: (bytes, offset) => {
       codecsCore.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) {
@@ -294,337 +257,300 @@ function getDataEnumDecoder(variants, options = {}) {
           `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, options = {}) {
-  return codecsCore.combineCodec(getDataEnumEncoder(variants, options), getDataEnumDecoder(variants, options));
+function getDataEnumCodec(variants, config = {}) {
+  return codecsCore.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 codecsCore.isFixedSize(prefix) ? prefix.fixedSize : null;
+  if (!codecsCore.isFixedSize(variants[0][1]))
+    return null;
+  const variantSize = variants[0][1].fixedSize;
+  const sameSizedVariants = variants.every(
+    (variant) => codecsCore.isFixedSize(variant[1]) && variant[1].fixedSize === variantSize
+  );
+  if (!sameSizedVariants)
+    return null;
+  return codecsCore.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])
-  };
-}
-function getMapEncoder(key, value, options = {}) {
-  const size = options.size ?? codecsNumbers.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]) => codecsCore.mergeBytes([key.encode(k), value.encode(v)]));
-      return codecsCore.mergeBytes([getArrayLikeCodecSizePrefix(size, map.size), ...itemBytes]);
+  return discriminator;
+}
+function getTupleEncoder(items) {
+  const fixedSize = sumCodecSizes(items.map(getFixedSize));
+  const maxSize = sumCodecSizes(items.map(getMaxSize)) ?? void 0;
+  return codecsCore.createEncoder({
+    ...fixedSize === null ? {
+      getSizeFromValue: (value) => items.map((item, index) => codecsCore.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 codecsCore.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 getMapDecoder(key, value, options = {}) {
-  const size = options.size ?? codecsNumbers.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];
+function getTupleCodec(items) {
+  return codecsCore.combineCodec(
+    getTupleEncoder(items),
+    getTupleDecoder(items)
+  );
+}
+
+// src/map.ts
+function getMapEncoder(key, value, config = {}) {
+  return codecsCore.mapEncoder(
+    getArrayEncoder(getTupleEncoder([key, value]), config),
+    (map) => [...map.entries()]
+  );
+}
+function getMapDecoder(key, value, config = {}) {
+  return codecsCore.mapDecoder(
+    getArrayDecoder(getTupleDecoder([key, value]), config),
+    (entries) => new Map(entries)
+  );
+}
+function getMapCodec(key, value, config = {}) {
+  return codecsCore.combineCodec(getMapEncoder(key, value, config), getMapDecoder(key, value, config));
+}
+function getNullableEncoder(item, config = {}) {
+  const prefix = config.prefix ?? codecsNumbers.getU8Encoder();
+  const fixed = config.fixed ?? false;
+  const isZeroSizeItem = codecsCore.isFixedSize(item) && codecsCore.isFixedSize(prefix) && item.fixedSize === 0;
+  if (fixed || isZeroSizeItem) {
+    try {
+      codecsCore.assertIsFixedSize(item);
+    } catch (e) {
+      throw new Error("Fixed nullables can only be used with fixed-size codecs.");
+    }
+    try {
+      codecsCore.assertIsFixedSize(prefix);
+    } catch (e) {
+      throw new Error("Fixed nullables can only be used with fixed-size prefix.");
+    }
+    const fixedSize = prefix.fixedSize + item.fixedSize;
+    return codecsCore.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;
       }
-      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 codecsCore.createEncoder({
+    getSizeFromValue: (option) => codecsCore.getEncodedSize(Number(option !== null), prefix) + (option !== null ? codecsCore.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 [map, offset];
+      return offset;
+    }
+  });
+}
+function getNullableDecoder(item, config = {}) {
+  const prefix = config.prefix ?? codecsNumbers.getU8Decoder();
+  const fixed = config.fixed ?? false;
+  let fixedSize = null;
+  const isZeroSizeItem = codecsCore.isFixedSize(item) && codecsCore.isFixedSize(prefix) && item.fixedSize === 0;
+  if (fixed || isZeroSizeItem) {
+    try {
+      codecsCore.assertIsFixedSize(item);
+    } catch (e) {
+      throw new Error("Fixed nullables can only be used with fixed-size codecs.");
+    }
+    try {
+      codecsCore.assertIsFixedSize(prefix);
+    } catch (e) {
+      throw new Error("Fixed nullables can only be used with fixed-size prefix.");
     }
-  };
-}
-function getMapCodec(key, value, options = {}) {
-  return codecsCore.combineCodec(getMapEncoder(key, value, options), getMapDecoder(key, value, options));
-}
-function nullableCodecHelper(item, prefix, fixed, description) {
-  let descriptionSuffix = `; ${prefix.description}`;
-  let fixedSize = item.fixedSize === 0 ? prefix.fixedSize : null;
-  if (fixed) {
-    codecsCore.assertFixedSizeCodec(item, "Fixed nullables can only be used with fixed-size codecs.");
-    codecsCore.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, options = {}) {
-  const prefix = options.prefix ?? codecsNumbers.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 ? codecsCore.fixBytes(itemBytes, item.fixedSize) : itemBytes;
-      return codecsCore.mergeBytes([prefixByte, itemBytes]);
-    }
-  };
-}
-function getNullableDecoder(item, options = {}) {
-  const prefix = options.prefix ?? codecsNumbers.getU8Decoder();
-  const fixed = options.fixed ?? false;
-  return {
-    ...nullableCodecHelper(item, prefix, fixed, options.description),
-    decode: (bytes, offset = 0) => {
+  return codecsCore.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 = {}) {
+  const configCast = config;
+  return codecsCore.combineCodec(getNullableEncoder(item, configCast), getNullableDecoder(item, configCast));
+}
+function getScalarEnumEncoder(constructor, config = {}) {
+  const prefix = config.size ?? codecsNumbers.getU8Encoder();
+  const { minRange, maxRange, allStringInputs, enumKeys, enumValues } = getScalarEnumStats(constructor);
+  return codecsCore.mapEncoder(prefix, (value) => {
+    const isInvalidNumber = typeof value === "number" && (value < minRange || value > maxRange);
+    const isInvalidString = typeof value === "string" && !allStringInputs.includes(value);
+    if (isInvalidNumber || isInvalidString) {
+      throw new Error(
+        `Invalid scalar enum variant. Expected one of [${allStringInputs.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 ?? codecsNumbers.getU8Decoder();
+  const { minRange, maxRange, enumKeys } = getScalarEnumStats(constructor);
+  return codecsCore.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 constructor[enumKeys[valueAsNumber]];
+  });
 }
-function getNullableCodec(item, options = {}) {
-  return codecsCore.combineCodec(getNullableEncoder(item, options), getNullableDecoder(item, options));
+function getScalarEnumCodec(constructor, config = {}) {
+  return codecsCore.combineCodec(getScalarEnumEncoder(constructor, config), getScalarEnumDecoder(constructor, config));
 }
-function scalarEnumCoderHelper(constructor, prefix, description) {
-  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(", ");
+function getScalarEnumStats(constructor) {
+  const numericValues = Object.values(constructor).filter((v) => typeof v === "number");
+  const deduplicatedConstructor = Object.fromEntries(
+    Object.entries(constructor).slice(numericValues.length)
+  );
+  const enumKeys = Object.keys(deduplicatedConstructor);
+  const enumValues = Object.values(deduplicatedConstructor);
   const minRange = 0;
-  const maxRange = isNumericEnum ? enumValues.length / 2 - 1 : enumValues.length - 1;
-  const stringValues = isNumericEnum ? [...enumKeys] : [.../* @__PURE__ */ new Set([...enumKeys, ...enumValues])];
+  const maxRange = enumValues.length - 1;
+  const allStringInputs = [
+    .../* @__PURE__ */ new Set([...enumKeys, ...enumValues.filter((v) => typeof v === "string")])
+  ];
   return {
-    description: description ?? `enum(${valueDescriptions}; ${prefix.description})`,
+    allStringInputs,
     enumKeys,
     enumValues,
-    fixedSize: prefix.fixedSize,
-    isNumericEnum,
     maxRange,
-    maxSize: prefix.maxSize,
-    minRange,
-    stringValues
+    minRange
   };
 }
-function getScalarEnumEncoder(constructor, options = {}) {
-  const prefix = options.size ?? codecsNumbers.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 getSetEncoder(item, config = {}) {
+  return codecsCore.mapEncoder(getArrayEncoder(item, config), (set) => [...set]);
 }
-function getScalarEnumDecoder(constructor, options = {}) {
-  const prefix = options.size ?? codecsNumbers.getU8Decoder();
-  const { description, fixedSize, maxSize, minRange, maxRange, isNumericEnum, enumValues } = scalarEnumCoderHelper(
-    constructor,
-    prefix,
-    options.description
-  );
-  return {
-    decode: (bytes, offset = 0) => {
-      codecsCore.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 codecsCore.combineCodec(getScalarEnumEncoder(constructor, options), getScalarEnumDecoder(constructor, options));
+function getSetDecoder(item, config = {}) {
+  return codecsCore.mapDecoder(getArrayDecoder(item, config), (entries) => new Set(entries));
 }
-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, options = {}) {
-  const size = options.size ?? codecsNumbers.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 codecsCore.mergeBytes([getArrayLikeCodecSizePrefix(size, set.size), ...itemBytes]);
-    }
-  };
+function getSetCodec(item, config = {}) {
+  return codecsCore.combineCodec(getSetEncoder(item, config), getSetDecoder(item, config));
 }
-function getSetDecoder(item, options = {}) {
-  const size = options.size ?? codecsNumbers.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 codecsCore.combineCodec(getSetEncoder(item, options), getSetDecoder(item, options));
-}
-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 codecsCore.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 codecsCore.createEncoder({
+    ...fixedSize === null ? {
+      getSizeFromValue: (value) => fields.map(([key, codec]) => codecsCore.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) {
+  const fieldCodecs = fields.map(([, codec]) => codec);
+  const fixedSize = sumCodecSizes(fieldCodecs.map(getFixedSize));
+  const maxSize = sumCodecSizes(fieldCodecs.map(getMaxSize)) ?? void 0;
+  return codecsCore.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 codecsCore.combineCodec(getStructEncoder(fields, options), getStructDecoder(fields, options));
-}
-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 codecsCore.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 = {}) {
+function getStructCodec(fields) {
   return codecsCore.combineCodec(
-    getTupleEncoder(items, options),
-    getTupleDecoder(items, options)
+    getStructEncoder(fields),
+    getStructDecoder(fields)
   );
 }
-function getUnitEncoder(options = {}) {
-  return {
-    description: options.description ?? "unit",
-    encode: () => new Uint8Array(),
+function getUnitEncoder() {
+  return codecsCore.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 codecsCore.createDecoder({
     fixedSize: 0,
-    maxSize: 0
-  };
+    read: (_bytes, offset) => [void 0, offset]
+  });
 }
-function getUnitCodec(options = {}) {
-  return codecsCore.combineCodec(getUnitEncoder(options), getUnitDecoder(options));
+function getUnitCodec() {
+  return codecsCore.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;