@solana/codecs-data-structures 2.0.0-experimental.5e8ac8d

package/dist/index.node.cjs

@@ -0,0 +1,662 @@
+'use strict';
+
+var codecsCore = require('@solana/codecs-core');
+var codecsNumbers = require('@solana/codecs-numbers');
+
+// src/array.ts
+
+// src/utils.ts
+function maxCodecSizes(sizes) {
+  return sizes.reduce(
+    (all, size) => all === null || size === null ? null : Math.max(all, size),
+    0
+  );
+}
+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 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 ?? codecsNumbers.getU32Encoder();
+  return {
+    ...arrayCodecHelper(item, size, options.description),
+    encode: (value) => {
+      if (typeof size === "number") {
+        assertValidNumberOfItemsForCodec("array", size, value.length);
+      }
+      return codecsCore.mergeBytes([getArrayLikeCodecSizePrefix(size, value.length), ...value.map((v) => item.encode(v))]);
+    }
+  };
+}
+function getArrayDecoder(item, options = {}) {
+  const size = options.size ?? codecsNumbers.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 codecsCore.combineCodec(getArrayEncoder(item, options), getArrayDecoder(item, options));
+}
+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 = [];
+      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);
+          byte |= feature << (backward ? j : 7 - j);
+        }
+        if (backward) {
+          bytes.unshift(byte);
+        } else {
+          bytes.push(byte);
+        }
+      }
+      return new Uint8Array(bytes);
+    },
+    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) {
+      codecsCore.assertByteArrayHasEnoughBytesForCodec("bitArray", size, bytes, offset);
+      const booleans = [];
+      let slice = bytes.slice(offset, offset + size);
+      slice = backward ? slice.reverse() : slice;
+      slice.forEach((byte) => {
+        for (let i = 0; i < 8; i += 1) {
+          if (backward) {
+            booleans.push(Boolean(byte & 1));
+            byte >>= 1;
+          } else {
+            booleans.push(Boolean(byte & 128));
+            byte <<= 1;
+          }
+        }
+      });
+      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 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
+  };
+  if (size === "variable") {
+    return byteEncoder;
+  }
+  if (typeof size === "number") {
+    return codecsCore.fixEncoder(byteEncoder, size, description);
+  }
+  return {
+    ...byteEncoder,
+    encode: (value) => {
+      const contentBytes = byteEncoder.encode(value);
+      const lengthBytes = size.encode(contentBytes.length);
+      return codecsCore.mergeBytes([lengthBytes, contentBytes]);
+    }
+  };
+}
+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) => {
+      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 {
+    ...byteDecoder,
+    decode: (bytes, offset = 0) => {
+      codecsCore.assertByteArrayIsNotEmptyForCodec("bytes", bytes, offset);
+      const [lengthBigInt, lengthOffset] = size.decode(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);
+      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 getDataEnumDecoder(variants, options = {}) {
+  const prefix = options.size ?? codecsNumbers.getU8Decoder();
+  return {
+    ...dataEnumCodecHelper(variants, prefix, options.description),
+    decode: (bytes, offset = 0) => {
+      codecsCore.assertByteArrayIsNotEmptyForCodec("dataEnum", bytes, offset);
+      const [discriminator, dOffset] = prefix.decode(bytes, offset);
+      offset = dOffset;
+      const variantField = variants[Number(discriminator)] ?? 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);
+      offset = vOffset;
+      return [{ __kind: variantField[0], ...variant ?? {} }, offset];
+    }
+  };
+}
+function getDataEnumCodec(variants, options = {}) {
+  return codecsCore.combineCodec(getDataEnumEncoder(variants, options), getDataEnumDecoder(variants, options));
+}
+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.');
+  }
+  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]);
+    }
+  };
+}
+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];
+      }
+      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 getMapCodec(key, value, options = {}) {
+  return codecsCore.combineCodec(getMapEncoder(key, value, options), getMapDecoder(key, value, options));
+}
+function nullableCodecHelper(item, prefix, fixed, description) {
+  let descriptionSuffix = `; ${getArrayLikeCodecSizeDescription(prefix)}`;
+  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) => {
+      if (bytes.slice(offset).length === 0) {
+        return [null, offset];
+      }
+      const fixedOffset = offset + (prefix.fixedSize ?? 0) + (item.fixedSize ?? 0);
+      const [isSome, prefixOffset] = prefix.decode(bytes, offset);
+      offset = prefixOffset;
+      if (isSome === 0) {
+        return [null, fixed ? fixedOffset : offset];
+      }
+      const [value, newOffset] = item.decode(bytes, offset);
+      offset = newOffset;
+      return [value, fixed ? fixedOffset : offset];
+    }
+  };
+}
+function getNullableCodec(item, options = {}) {
+  return codecsCore.combineCodec(getNullableEncoder(item, options), getNullableDecoder(item, options));
+}
+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(", ");
+  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 ?? 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 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 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 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 getStructDecoder(fields, options = {}) {
+  return {
+    ...structCodecHelper(fields, options.description),
+    decode: (bytes, offset = 0) => {
+      const struct = {};
+      fields.forEach(([key, codec]) => {
+        const [value, newOffset] = codec.decode(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 = {}) {
+  return codecsCore.combineCodec(
+    getTupleEncoder(items, options),
+    getTupleDecoder(items, options)
+  );
+}
+function getUnitEncoder(options = {}) {
+  return {
+    description: options.description ?? "unit",
+    encode: () => new Uint8Array(),
+    fixedSize: 0,
+    maxSize: 0
+  };
+}
+function getUnitDecoder(options = {}) {
+  return {
+    decode: (_bytes, offset = 0) => [void 0, offset],
+    description: options.description ?? "unit",
+    fixedSize: 0,
+    maxSize: 0
+  };
+}
+function getUnitCodec(options = {}) {
+  return codecsCore.combineCodec(getUnitEncoder(options), getUnitDecoder(options));
+}
+
+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;
+exports.getBooleanCodec = getBooleanCodec;
+exports.getBooleanDecoder = getBooleanDecoder;
+exports.getBooleanEncoder = getBooleanEncoder;
+exports.getBytesCodec = getBytesCodec;
+exports.getBytesDecoder = getBytesDecoder;
+exports.getBytesEncoder = getBytesEncoder;
+exports.getDataEnumCodec = getDataEnumCodec;
+exports.getDataEnumDecoder = getDataEnumDecoder;
+exports.getDataEnumEncoder = getDataEnumEncoder;
+exports.getMapCodec = getMapCodec;
+exports.getMapDecoder = getMapDecoder;
+exports.getMapEncoder = getMapEncoder;
+exports.getNullableCodec = getNullableCodec;
+exports.getNullableDecoder = getNullableDecoder;
+exports.getNullableEncoder = getNullableEncoder;
+exports.getScalarEnumCodec = getScalarEnumCodec;
+exports.getScalarEnumDecoder = getScalarEnumDecoder;
+exports.getScalarEnumEncoder = getScalarEnumEncoder;
+exports.getSetCodec = getSetCodec;
+exports.getSetDecoder = getSetDecoder;
+exports.getSetEncoder = getSetEncoder;
+exports.getStructCodec = getStructCodec;
+exports.getStructDecoder = getStructDecoder;
+exports.getStructEncoder = getStructEncoder;
+exports.getTupleCodec = getTupleCodec;
+exports.getTupleDecoder = getTupleDecoder;
+exports.getTupleEncoder = getTupleEncoder;
+exports.getUnitCodec = getUnitCodec;
+exports.getUnitDecoder = getUnitDecoder;
+exports.getUnitEncoder = getUnitEncoder;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.node.cjs.map