@hfunlabs/hyperliquid 0.30.2-hfunlabs.2 → 0.32.2-hfunlabs.3

package/esm/deps/jsr.io/@paulmillr/micro-packed/0.8.0/src/index.js

@@ -1,2001 +0,0 @@
-import { hex as baseHex, utf8 } from '../../../../@scure/base/2.0.0/index.js';
-/**
- * Define complex binary structures using composable primitives.
- * Main ideas:
- * - Encode / decode can be chained, same as in `scure-base`
- * - A complex structure can be created from an array and struct of primitive types
- * - Strings / bytes are arrays with specific optimizations: we can just read bytes directly
- *   without creating plain array first and reading each byte separately.
- * - Types are inferred from definition
- * @module
- * @example
- * import * as P from 'micro-packed';
- * const s = P.struct({
- *   field1: P.U32BE, // 32-bit unsigned big-endian integer
- *   field2: P.string(P.U8), // String with U8 length prefix
- *   field3: P.bytes(32), // 32 bytes
- *   field4: P.array(P.U16BE, P.struct({ // Array of structs with U16BE length
- *     subField1: P.U64BE, // 64-bit unsigned big-endian integer
- *     subField2: P.string(10) // 10-byte string
- *   }))
- * });
- */
-// TODO: remove dependency on scure-base & inline?
-/*
-Exports can be groupped like this:
-
-- Primitive types: P.bytes, P.string, P.hex, P.constant, P.pointer
-- Complex types: P.array, P.struct, P.tuple, P.map, P.tag, P.mappedTag
-- Padding, prefix, magic: P.padLeft, P.padRight, P.prefix, P.magic, P.magicBytes
-- Flags: P.flag, P.flagged, P.optional
-- Wrappers: P.apply, P.wrap, P.lazy
-- Bit fiddling: P.bits, P.bitset
-- utils: P.validate, coders.decimal
-- Debugger
-*/
-/** Shortcut to zero-length (empty) byte array */
-export const EMPTY = /* @__PURE__ */ Uint8Array.of();
-/** Shortcut to one-element (element is 0) byte array */
-export const NULL = /* @__PURE__ */ Uint8Array.of(0);
-/** Checks if two Uint8Arrays are equal. Not constant-time. */
-function equalBytes(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++)
-        if (a[i] !== b[i])
-            return false;
-    return true;
-}
-/** Checks if the given value is a Uint8Array. */
-function isBytes(a) {
-    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
-}
-/**
- * Concatenates multiple Uint8Arrays.
- * Engines limit functions to 65K+ arguments.
- * @param arrays Array of Uint8Array elements
- * @returns Concatenated Uint8Array
- */
-function concatBytes(...arrays) {
-    let sum = 0;
-    for (let i = 0; i < arrays.length; i++) {
-        const a = arrays[i];
-        if (!isBytes(a))
-            throw new Error('Uint8Array expected');
-        sum += a.length;
-    }
-    const res = new Uint8Array(sum);
-    for (let i = 0, pad = 0; i < arrays.length; i++) {
-        const a = arrays[i];
-        res.set(a, pad);
-        pad += a.length;
-    }
-    return res;
-}
-/**
- * Creates DataView from Uint8Array
- * @param arr - bytes
- * @returns DataView
- */
-const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-/**
- * Checks if the provided value is a plain object, not created from any class or special constructor.
- * Array, Uint8Array and others are not plain objects.
- * @param obj - The value to be checked.
- */
-function isPlainObject(obj) {
-    return Object.prototype.toString.call(obj) === '[object Object]';
-}
-function isNum(num) {
-    return Number.isSafeInteger(num);
-}
-export const utils = {
-    equalBytes,
-    isBytes,
-    isCoder,
-    checkBounds,
-    concatBytes,
-    createView,
-    isPlainObject,
-};
-// NOTE: we can't have terminator separate function, since it won't know about boundaries
-// E.g. array of U16LE ([1,2,3]) would be [1, 0, 2, 0, 3, 0]
-// But terminator will find array at index '1', which happens to be inside of an element itself
-/**
- * Can be:
- * - Dynamic (CoderType)
- * - Fixed (number)
- * - Terminated (usually zero): Uint8Array with terminator
- * - Field path to field with length (string)
- * - Infinity (null) - decodes until end of buffer
- * Used in:
- * - bytes (string, prefix is implementation of bytes)
- * - array
- */
-const lengthCoder = (len) => {
-    if (len !== null && typeof len !== 'string' && !isCoder(len) && !isBytes(len) && !isNum(len)) {
-        throw new Error(`lengthCoder: expected null | number | Uint8Array | CoderType, got ${len} (${typeof len})`);
-    }
-    return {
-        encodeStream(w, value) {
-            if (len === null)
-                return;
-            if (isCoder(len))
-                return len.encodeStream(w, value);
-            let byteLen;
-            if (typeof len === 'number')
-                byteLen = len;
-            else if (typeof len === 'string')
-                byteLen = Path.resolve(w.stack, len);
-            if (typeof byteLen === 'bigint')
-                byteLen = Number(byteLen);
-            if (byteLen === undefined || byteLen !== value)
-                throw w.err(`Wrong length: ${byteLen} len=${len} exp=${value} (${typeof value})`);
-        },
-        decodeStream(r) {
-            let byteLen;
-            if (isCoder(len))
-                byteLen = Number(len.decodeStream(r));
-            else if (typeof len === 'number')
-                byteLen = len;
-            else if (typeof len === 'string')
-                byteLen = Path.resolve(r.stack, len);
-            if (typeof byteLen === 'bigint')
-                byteLen = Number(byteLen);
-            if (typeof byteLen !== 'number')
-                throw r.err(`Wrong length: ${byteLen}`);
-            return byteLen;
-        },
-    };
-};
-/**
- * Small bitset structure to store position of ranges that have been read.
- * Can be more efficient when internal trees are utilized at the cost of complexity.
- * Needs `O(N/8)` memory for parsing.
- * Purpose: if there are pointers in parsed structure,
- * they can cause read of two distinct ranges:
- * [0-32, 64-128], which means 'pos' is not enough to handle them
- */
-const Bitset = {
-    BITS: 32,
-    FULL_MASK: -1 >>> 0, // 1<<32 will overflow
-    len: (len) => Math.ceil(len / 32),
-    create: (len) => new Uint32Array(Bitset.len(len)),
-    clean: (bs) => bs.fill(0),
-    debug: (bs) => Array.from(bs).map((i) => (i >>> 0).toString(2).padStart(32, '0')),
-    checkLen: (bs, len) => {
-        if (Bitset.len(len) === bs.length)
-            return;
-        throw new Error(`wrong length=${bs.length}. Expected: ${Bitset.len(len)}`);
-    },
-    chunkLen: (bsLen, pos, len) => {
-        if (pos < 0)
-            throw new Error(`wrong pos=${pos}`);
-        if (pos + len > bsLen)
-            throw new Error(`wrong range=${pos}/${len} of ${bsLen}`);
-    },
-    set: (bs, chunk, value, allowRewrite = true) => {
-        if (!allowRewrite && (bs[chunk] & value) !== 0)
-            return false;
-        bs[chunk] |= value;
-        return true;
-    },
-    pos: (pos, i) => ({
-        chunk: Math.floor((pos + i) / 32),
-        mask: 1 << (32 - ((pos + i) % 32) - 1),
-    }),
-    indices: (bs, len, invert = false) => {
-        Bitset.checkLen(bs, len);
-        const { FULL_MASK, BITS } = Bitset;
-        const left = BITS - (len % BITS);
-        const lastMask = left ? (FULL_MASK >>> left) << left : FULL_MASK;
-        const res = [];
-        for (let i = 0; i < bs.length; i++) {
-            let c = bs[i];
-            if (invert)
-                c = ~c; // allows to gen unset elements
-            // apply mask to last element, so we won't iterate non-existent items
-            if (i === bs.length - 1)
-                c &= lastMask;
-            if (c === 0)
-                continue; // fast-path
-            for (let j = 0; j < BITS; j++) {
-                const m = 1 << (BITS - j - 1);
-                if (c & m)
-                    res.push(i * BITS + j);
-            }
-        }
-        return res;
-    },
-    range: (arr) => {
-        const res = [];
-        let cur;
-        for (const i of arr) {
-            if (cur === undefined || i !== cur.pos + cur.length)
-                res.push((cur = { pos: i, length: 1 }));
-            else
-                cur.length += 1;
-        }
-        return res;
-    },
-    rangeDebug: (bs, len, invert = false) => `[${Bitset.range(Bitset.indices(bs, len, invert))
-        .map((i) => `(${i.pos}/${i.length})`)
-        .join(', ')}]`,
-    setRange: (bs, bsLen, pos, len, allowRewrite = true) => {
-        Bitset.chunkLen(bsLen, pos, len);
-        const { FULL_MASK, BITS } = Bitset;
-        // Try to set range with maximum efficiency:
-        // - first chunk is always    '0000[1111]' (only right ones)
-        // - middle chunks are set to '[1111 1111]' (all ones)
-        // - last chunk is always     '[1111]0000' (only left ones)
-        // - max operations:          (N/32) + 2 (first and last)
-        const first = pos % BITS ? Math.floor(pos / BITS) : undefined;
-        const lastPos = pos + len;
-        const last = lastPos % BITS ? Math.floor(lastPos / BITS) : undefined;
-        // special case, whole range inside single chunk
-        if (first !== undefined && first === last)
-            return Bitset.set(bs, first, (FULL_MASK >>> (BITS - len)) << (BITS - len - pos), allowRewrite);
-        if (first !== undefined) {
-            if (!Bitset.set(bs, first, FULL_MASK >>> pos % BITS, allowRewrite))
-                return false; // first chunk
-        }
-        // middle chunks
-        const start = first !== undefined ? first + 1 : pos / BITS;
-        const end = last !== undefined ? last : lastPos / BITS;
-        for (let i = start; i < end; i++)
-            if (!Bitset.set(bs, i, FULL_MASK, allowRewrite))
-                return false;
-        if (last !== undefined && first !== last)
-            if (!Bitset.set(bs, last, FULL_MASK << (BITS - (lastPos % BITS)), allowRewrite))
-                return false; // last chunk
-        return true;
-    },
-};
-const Path = {
-    /**
-     * Internal method for handling stack of paths (debug, errors, dynamic fields via path)
-     * This is looks ugly (callback), but allows us to force stack cleaning by construction (.pop always after function).
-     * Also, this makes impossible:
-     * - pushing field when stack is empty
-     * - pushing field inside of field (real bug)
-     * NOTE: we don't want to do '.pop' on error!
-     */
-    pushObj: (stack, obj, objFn) => {
-        const last = { obj };
-        stack.push(last);
-        objFn((field, fieldFn) => {
-            last.field = field;
-            fieldFn();
-            last.field = undefined;
-        });
-        stack.pop();
-    },
-    path: (stack) => {
-        const res = [];
-        for (const i of stack)
-            if (i.field !== undefined)
-                res.push(i.field);
-        return res.join('/');
-    },
-    err: (name, stack, msg) => {
-        const err = new Error(`${name}(${Path.path(stack)}): ${typeof msg === 'string' ? msg : msg.message}`);
-        if (msg instanceof Error && msg.stack)
-            err.stack = msg.stack;
-        return err;
-    },
-    resolve: (stack, path) => {
-        const parts = path.split('/');
-        const objPath = stack.map((i) => i.obj);
-        let i = 0;
-        for (; i < parts.length; i++) {
-            if (parts[i] === '..')
-                objPath.pop();
-            else
-                break;
-        }
-        let cur = objPath.pop();
-        for (; i < parts.length; i++) {
-            if (!cur || cur[parts[i]] === undefined)
-                return undefined;
-            cur = cur[parts[i]];
-        }
-        return cur;
-    },
-};
-/**
- * Internal structure. Reader class for reading from a byte array.
- * `stack` is internal: for debugger and logging
- * @class Reader
- */
-class _Reader {
-    pos = 0;
-    data;
-    opts;
-    stack;
-    parent;
-    parentOffset;
-    bitBuf = 0;
-    bitPos = 0;
-    bs; // bitset
-    view;
-    constructor(data, opts = {}, stack = [], parent = undefined, parentOffset = 0) {
-        this.data = data;
-        this.opts = opts;
-        this.stack = stack;
-        this.parent = parent;
-        this.parentOffset = parentOffset;
-        this.view = createView(data);
-    }
-    /** Internal method for pointers. */
-    _enablePointers() {
-        if (this.parent)
-            return this.parent._enablePointers();
-        if (this.bs)
-            return;
-        this.bs = Bitset.create(this.data.length);
-        Bitset.setRange(this.bs, this.data.length, 0, this.pos, this.opts.allowMultipleReads);
-    }
-    markBytesBS(pos, len) {
-        if (this.parent)
-            return this.parent.markBytesBS(this.parentOffset + pos, len);
-        if (!len)
-            return true;
-        if (!this.bs)
-            return true;
-        return Bitset.setRange(this.bs, this.data.length, pos, len, false);
-    }
-    markBytes(len) {
-        const pos = this.pos;
-        this.pos += len;
-        const res = this.markBytesBS(pos, len);
-        if (!this.opts.allowMultipleReads && !res)
-            throw this.err(`multiple read pos=${this.pos} len=${len}`);
-        return res;
-    }
-    pushObj(obj, objFn) {
-        return Path.pushObj(this.stack, obj, objFn);
-    }
-    readView(n, fn) {
-        if (!Number.isFinite(n))
-            throw this.err(`readView: wrong length=${n}`);
-        if (this.pos + n > this.data.length)
-            throw this.err('readView: Unexpected end of buffer');
-        const res = fn(this.view, this.pos);
-        this.markBytes(n);
-        return res;
-    }
-    // read bytes by absolute offset
-    absBytes(n) {
-        if (n > this.data.length)
-            throw new Error('Unexpected end of buffer');
-        return this.data.subarray(n);
-    }
-    finish() {
-        if (this.opts.allowUnreadBytes)
-            return;
-        if (this.bitPos) {
-            throw this.err(`${this.bitPos} bits left after unpack: ${baseHex.encode(this.data.slice(this.pos))}`);
-        }
-        if (this.bs && !this.parent) {
-            const notRead = Bitset.indices(this.bs, this.data.length, true);
-            if (notRead.length) {
-                const formatted = Bitset.range(notRead)
-                    .map(({ pos, length }) => `(${pos}/${length})[${baseHex.encode(this.data.subarray(pos, pos + length))}]`)
-                    .join(', ');
-                throw this.err(`unread byte ranges: ${formatted} (total=${this.data.length})`);
-            }
-            else
-                return; // all bytes read, everything is ok
-        }
-        // Default: no pointers enabled
-        if (!this.isEnd()) {
-            throw this.err(`${this.leftBytes} bytes ${this.bitPos} bits left after unpack: ${baseHex.encode(this.data.slice(this.pos))}`);
-        }
-    }
-    // User methods
-    err(msg) {
-        return Path.err('Reader', this.stack, msg);
-    }
-    offsetReader(n) {
-        if (n > this.data.length)
-            throw this.err('offsetReader: Unexpected end of buffer');
-        return new _Reader(this.absBytes(n), this.opts, this.stack, this, n);
-    }
-    bytes(n, peek = false) {
-        if (this.bitPos)
-            throw this.err('readBytes: bitPos not empty');
-        if (!Number.isFinite(n))
-            throw this.err(`readBytes: wrong length=${n}`);
-        if (this.pos + n > this.data.length)
-            throw this.err('readBytes: Unexpected end of buffer');
-        const slice = this.data.subarray(this.pos, this.pos + n);
-        if (!peek)
-            this.markBytes(n);
-        return slice;
-    }
-    byte(peek = false) {
-        if (this.bitPos)
-            throw this.err('readByte: bitPos not empty');
-        if (this.pos + 1 > this.data.length)
-            throw this.err('readBytes: Unexpected end of buffer');
-        const data = this.data[this.pos];
-        if (!peek)
-            this.markBytes(1);
-        return data;
-    }
-    get leftBytes() {
-        return this.data.length - this.pos;
-    }
-    get totalBytes() {
-        return this.data.length;
-    }
-    isEnd() {
-        return this.pos >= this.data.length && !this.bitPos;
-    }
-    // bits are read in BE mode (left to right): (0b1000_0000).readBits(1) == 1
-    bits(bits) {
-        if (bits > 32)
-            throw this.err('BitReader: cannot read more than 32 bits in single call');
-        let out = 0;
-        while (bits) {
-            if (!this.bitPos) {
-                this.bitBuf = this.byte();
-                this.bitPos = 8;
-            }
-            const take = Math.min(bits, this.bitPos);
-            this.bitPos -= take;
-            out = (out << take) | ((this.bitBuf >> this.bitPos) & (2 ** take - 1));
-            this.bitBuf &= 2 ** this.bitPos - 1;
-            bits -= take;
-        }
-        // Fix signed integers
-        return out >>> 0;
-    }
-    find(needle, pos = this.pos) {
-        if (!isBytes(needle))
-            throw this.err(`find: needle is not bytes! ${needle}`);
-        if (this.bitPos)
-            throw this.err('findByte: bitPos not empty');
-        if (!needle.length)
-            throw this.err(`find: needle is empty`);
-        // indexOf should be faster than full equalBytes check
-        for (let idx = pos; (idx = this.data.indexOf(needle[0], idx)) !== -1; idx++) {
-            if (idx === -1)
-                return;
-            const leftBytes = this.data.length - idx;
-            if (leftBytes < needle.length)
-                return;
-            if (equalBytes(needle, this.data.subarray(idx, idx + needle.length)))
-                return idx;
-        }
-        return;
-    }
-}
-/**
- * Internal structure. Writer class for writing to a byte array.
- * The `stack` argument of constructor is internal, for debugging and logs.
- * @class Writer
- */
-class _Writer {
-    pos = 0;
-    stack;
-    // We could have a single buffer here and re-alloc it with
-    // x1.5-2 size each time it full, but it will be slower:
-    // basic/encode bench: 395ns -> 560ns
-    buffers = [];
-    ptrs = [];
-    bitBuf = 0;
-    bitPos = 0;
-    viewBuf = new Uint8Array(8);
-    view;
-    finished = false;
-    constructor(stack = []) {
-        this.stack = stack;
-        this.view = createView(this.viewBuf);
-    }
-    pushObj(obj, objFn) {
-        return Path.pushObj(this.stack, obj, objFn);
-    }
-    writeView(len, fn) {
-        if (this.finished)
-            throw this.err('buffer: finished');
-        if (!isNum(len) || len > 8)
-            throw new Error(`wrong writeView length=${len}`);
-        fn(this.view);
-        this.bytes(this.viewBuf.slice(0, len));
-        this.viewBuf.fill(0);
-    }
-    // User methods
-    err(msg) {
-        if (this.finished)
-            throw this.err('buffer: finished');
-        return Path.err('Reader', this.stack, msg);
-    }
-    bytes(b) {
-        if (this.finished)
-            throw this.err('buffer: finished');
-        if (this.bitPos)
-            throw this.err('writeBytes: ends with non-empty bit buffer');
-        this.buffers.push(b);
-        this.pos += b.length;
-    }
-    byte(b) {
-        if (this.finished)
-            throw this.err('buffer: finished');
-        if (this.bitPos)
-            throw this.err('writeByte: ends with non-empty bit buffer');
-        this.buffers.push(new Uint8Array([b]));
-        this.pos++;
-    }
-    finish(clean = true) {
-        if (this.finished)
-            throw this.err('buffer: finished');
-        if (this.bitPos)
-            throw this.err('buffer: ends with non-empty bit buffer');
-        // Can't use concatBytes, because it limits amount of arguments (65K).
-        const buffers = this.buffers.concat(this.ptrs.map((i) => i.buffer));
-        const sum = buffers.map((b) => b.length).reduce((a, b) => a + b, 0);
-        const buf = new Uint8Array(sum);
-        for (let i = 0, pad = 0; i < buffers.length; i++) {
-            const a = buffers[i];
-            buf.set(a, pad);
-            pad += a.length;
-        }
-        for (let pos = this.pos, i = 0; i < this.ptrs.length; i++) {
-            const ptr = this.ptrs[i];
-            buf.set(ptr.ptr.encode(pos), ptr.pos);
-            pos += ptr.buffer.length;
-        }
-        // Cleanup
-        if (clean) {
-            // We cannot cleanup buffers here, since it can be static user provided buffer.
-            // Only '.byte' and '.bits' create buffer which we can safely clean.
-            // for (const b of this.buffers) b.fill(0);
-            this.buffers = [];
-            for (const p of this.ptrs)
-                p.buffer.fill(0);
-            this.ptrs = [];
-            this.finished = true;
-            this.bitBuf = 0;
-        }
-        return buf;
-    }
-    bits(value, bits) {
-        if (bits > 32)
-            throw this.err('writeBits: cannot write more than 32 bits in single call');
-        if (value >= 2 ** bits)
-            throw this.err(`writeBits: value (${value}) >= 2**bits (${bits})`);
-        while (bits) {
-            const take = Math.min(bits, 8 - this.bitPos);
-            this.bitBuf = (this.bitBuf << take) | (value >> (bits - take));
-            this.bitPos += take;
-            bits -= take;
-            value &= 2 ** bits - 1;
-            if (this.bitPos === 8) {
-                this.bitPos = 0;
-                this.buffers.push(new Uint8Array([this.bitBuf]));
-                this.pos++;
-            }
-        }
-    }
-}
-// Immutable LE<->BE
-const swapEndianness = (b) => Uint8Array.from(b).reverse();
-/** Internal function for checking bit bounds of bigint in signed/unsinged form */
-function checkBounds(value, bits, signed) {
-    if (signed) {
-        // [-(2**(32-1)), 2**(32-1)-1]
-        const signBit = 2n ** (bits - 1n);
-        if (value < -signBit || value >= signBit)
-            throw new Error(`value out of signed bounds. Expected ${-signBit} <= ${value} < ${signBit}`);
-    }
-    else {
-        // [0, 2**32-1]
-        if (0n > value || value >= 2n ** bits)
-            throw new Error(`value out of unsigned bounds. Expected 0 <= ${value} < ${2n ** bits}`);
-    }
-}
-function _wrap(inner) {
-    return {
-        // NOTE: we cannot export validate here, since it is likely mistake.
-        encodeStream: inner.encodeStream,
-        decodeStream: inner.decodeStream,
-        size: inner.size,
-        encode: (value) => {
-            const w = new _Writer();
-            inner.encodeStream(w, value);
-            return w.finish();
-        },
-        decode: (data, opts = {}) => {
-            const r = new _Reader(data, opts);
-            const res = inner.decodeStream(r);
-            r.finish();
-            return res;
-        },
-    };
-}
-/**
- * Validates a value before encoding and after decoding using a provided function.
- * @param inner - The inner CoderType.
- * @param fn - The validation function.
- * @returns CoderType which check value with validation function.
- * @example
- * const val = (n: number) => {
- *   if (n > 10) throw new Error(`${n} > 10`);
- *   return n;
- * };
- *
- * const RangedInt = P.validate(P.U32LE, val); // Will check if value is <= 10 during encoding and decoding
- */
-export function validate(inner, fn) {
-    if (!isCoder(inner))
-        throw new Error(`validate: invalid inner value ${inner}`);
-    if (typeof fn !== 'function')
-        throw new Error('validate: fn should be function');
-    return _wrap({
-        size: inner.size,
-        encodeStream: (w, value) => {
-            let res;
-            try {
-                res = fn(value);
-            }
-            catch (e) {
-                throw w.err(e);
-            }
-            inner.encodeStream(w, res);
-        },
-        decodeStream: (r) => {
-            const res = inner.decodeStream(r);
-            try {
-                return fn(res);
-            }
-            catch (e) {
-                throw r.err(e);
-            }
-        },
-    });
-}
-/**
- * Wraps a stream encoder into a generic encoder and optionally validation function
- * @param {inner} inner BytesCoderStream & { validate?: Validate<T> }.
- * @returns The wrapped CoderType.
- * @example
- * const U8 = P.wrap({
- *   encodeStream: (w: Writer, value: number) => w.byte(value),
- *   decodeStream: (r: Reader): number => r.byte()
- * });
- * const checkedU8 = P.wrap({
- *   encodeStream: (w: Writer, value: number) => w.byte(value),
- *   decodeStream: (r: Reader): number => r.byte()
- *   validate: (n: number) => {
- *    if (n > 10) throw new Error(`${n} > 10`);
- *    return n;
- *   }
- * });
- */
-export const wrap = (inner) => {
-    const res = _wrap(inner);
-    return inner.validate ? validate(res, inner.validate) : res;
-};
-const isBaseCoder = (elm) => isPlainObject(elm) && typeof elm.decode === 'function' && typeof elm.encode === 'function';
-/**
- * Checks if the given value is a CoderType.
- * @param elm - The value to check.
- * @returns True if the value is a CoderType, false otherwise.
- */
-export function isCoder(elm) {
-    return (isPlainObject(elm) &&
-        isBaseCoder(elm) &&
-        typeof elm.encodeStream === 'function' &&
-        typeof elm.decodeStream === 'function' &&
-        (elm.size === undefined || isNum(elm.size)));
-}
-// Coders (like in @scure/base) for common operations
-/**
- * Base coder for working with dictionaries (records, objects, key-value map)
- * Dictionary is dynamic type like: `[key: string, value: any][]`
- * @returns base coder that encodes/decodes between arrays of key-value tuples and dictionaries.
- * @example
- * const dict: P.CoderType<Record<string, number>> = P.apply(
- *  P.array(P.U16BE, P.tuple([P.cstring, P.U32LE] as const)),
- *  P.coders.dict()
- * );
- */
-function dict() {
-    return {
-        encode: (from) => {
-            if (!Array.isArray(from))
-                throw new Error('array expected');
-            const to = {};
-            for (const item of from) {
-                if (!Array.isArray(item) || item.length !== 2)
-                    throw new Error(`array of two elements expected`);
-                const name = item[0];
-                const value = item[1];
-                if (to[name] !== undefined)
-                    throw new Error(`key(${name}) appears twice in struct`);
-                to[name] = value;
-            }
-            return to;
-        },
-        decode: (to) => {
-            if (!isPlainObject(to))
-                throw new Error(`expected plain object, got ${to}`);
-            return Object.entries(to);
-        },
-    };
-}
-/**
- * Safely converts bigint to number.
- * Sometimes pointers / tags use u64 or other big numbers which cannot be represented by number,
- * but we still can use them since real value will be smaller than u32
- */
-const numberBigint = {
-    encode: (from) => {
-        if (typeof from !== 'bigint')
-            throw new Error(`expected bigint, got ${typeof from}`);
-        if (from > BigInt(Number.MAX_SAFE_INTEGER))
-            throw new Error(`element bigger than MAX_SAFE_INTEGER=${from}`);
-        return Number(from);
-    },
-    decode: (to) => {
-        if (!isNum(to))
-            throw new Error('element is not a safe integer');
-        return BigInt(to);
-    },
-};
-/**
- * Base coder for working with TypeScript enums.
- * @param e - TypeScript enum.
- * @returns base coder that encodes/decodes between numbers and enum keys.
- * @example
- * enum Color { Red, Green, Blue }
- * const colorCoder = P.coders.tsEnum(Color);
- * colorCoder.encode(Color.Red); // 'Red'
- * colorCoder.decode('Green'); // 1
- */
-function tsEnum(e) {
-    if (!isPlainObject(e))
-        throw new Error('plain object expected');
-    return {
-        encode: (from) => {
-            if (!isNum(from) || !(from in e))
-                throw new Error(`wrong value ${from}`);
-            return e[from];
-        },
-        decode: (to) => {
-            if (typeof to !== 'string')
-                throw new Error(`wrong value ${typeof to}`);
-            return e[to];
-        },
-    };
-}
-/**
- * Base coder for working with decimal numbers.
- * @param precision - Number of decimal places.
- * @param round - Round fraction part if bigger than precision (throws error by default)
- * @returns base coder that encodes/decodes between bigints and decimal strings.
- * @example
- * const decimal8 = P.coders.decimal(8);
- * decimal8.encode(630880845n); // '6.30880845'
- * decimal8.decode('6.30880845'); // 630880845n
- */
-function decimal(precision, round = false) {
-    if (!isNum(precision))
-        throw new Error(`decimal/precision: wrong value ${precision}`);
-    if (typeof round !== 'boolean')
-        throw new Error(`decimal/round: expected boolean, got ${typeof round}`);
-    const decimalMask = 10n ** BigInt(precision);
-    return {
-        encode: (from) => {
-            if (typeof from !== 'bigint')
-                throw new Error(`expected bigint, got ${typeof from}`);
-            let s = (from < 0n ? -from : from).toString(10);
-            let sep = s.length - precision;
-            if (sep < 0) {
-                s = s.padStart(s.length - sep, '0');
-                sep = 0;
-            }
-            let i = s.length - 1;
-            for (; i >= sep && s[i] === '0'; i--)
-                ;
-            let int = s.slice(0, sep);
-            let frac = s.slice(sep, i + 1);
-            if (!int)
-                int = '0';
-            if (from < 0n)
-                int = '-' + int;
-            if (!frac)
-                return int;
-            return `${int}.${frac}`;
-        },
-        decode: (to) => {
-            if (typeof to !== 'string')
-                throw new Error(`expected string, got ${typeof to}`);
-            if (to === '-0')
-                throw new Error(`negative zero is not allowed`);
-            let neg = false;
-            if (to.startsWith('-')) {
-                neg = true;
-                to = to.slice(1);
-            }
-            if (!/^(0|[1-9]\d*)(\.\d+)?$/.test(to))
-                throw new Error(`wrong string value=${to}`);
-            let sep = to.indexOf('.');
-            sep = sep === -1 ? to.length : sep;
-            // split by separator and strip trailing zeros from fraction. always returns [string, string] (.split doesn't).
-            const intS = to.slice(0, sep);
-            const fracS = to.slice(sep + 1).replace(/0+$/, '');
-            const int = BigInt(intS) * decimalMask;
-            if (!round && fracS.length > precision) {
-                throw new Error(`fractional part cannot be represented with this precision (num=${to}, prec=${precision})`);
-            }
-            const fracLen = Math.min(fracS.length, precision);
-            const frac = BigInt(fracS.slice(0, fracLen)) * 10n ** BigInt(precision - fracLen);
-            const value = int + frac;
-            return neg ? -value : value;
-        },
-    };
-}
-/**
- * Combines multiple coders into a single coder, allowing conditional encoding/decoding based on input.
- * Acts as a parser combinator, splitting complex conditional coders into smaller parts.
- *
- *   `encode = [Ae, Be]; decode = [Ad, Bd]`
- *   ->
- *   `match([{encode: Ae, decode: Ad}, {encode: Be; decode: Bd}])`
- *
- * @param lst - Array of coders to match.
- * @returns Combined coder for conditional encoding/decoding.
- */
-function match(lst) {
-    if (!Array.isArray(lst))
-        throw new Error(`expected array, got ${typeof lst}`);
-    for (const i of lst)
-        if (!isBaseCoder(i))
-            throw new Error(`wrong base coder ${i}`);
-    return {
-        encode: (from) => {
-            for (const c of lst) {
-                const elm = c.encode(from);
-                if (elm !== undefined)
-                    return elm;
-            }
-            throw new Error(`match/encode: cannot find match in ${from}`);
-        },
-        decode: (to) => {
-            for (const c of lst) {
-                const elm = c.decode(to);
-                if (elm !== undefined)
-                    return elm;
-            }
-            throw new Error(`match/decode: cannot find match in ${to}`);
-        },
-    };
-}
-/** Reverses direction of coder */
-const reverse = (coder) => {
-    if (!isBaseCoder(coder))
-        throw new Error('BaseCoder expected');
-    return { encode: coder.decode, decode: coder.encode };
-};
-export const coders = { dict, numberBigint, tsEnum, decimal, match, reverse };
-/**
- * CoderType for parsing individual bits.
- * NOTE: Structure should parse whole amount of bytes before it can start parsing byte-level elements.
- * @param len - Number of bits to parse.
- * @returns CoderType representing the parsed bits.
- * @example
- * const s = P.struct({ magic: P.bits(1), version: P.bits(1), tag: P.bits(4), len: P.bits(2) });
- */
-export const bits = (len) => {
-    if (!isNum(len))
-        throw new Error(`bits: wrong length ${len} (${typeof len})`);
-    return wrap({
-        encodeStream: (w, value) => w.bits(value, len),
-        decodeStream: (r) => r.bits(len),
-        validate: (value) => {
-            if (!isNum(value))
-                throw new Error(`bits: wrong value ${value}`);
-            return value;
-        },
-    });
-};
-/**
- * CoderType for working with bigint values.
- * Unsized bigint values should be wrapped in a container (e.g., bytes or string).
- *
- * `0n = Uint8Array.of()`
- *
- * `1n = new Uint8Array([1n])`
- *
- * Please open issue, if you need different behavior for zero.
- *
- * @param size - Size of the bigint in bytes.
- * @param le - Whether to use little-endian byte order.
- * @param signed - Whether the bigint is signed.
- * @param sized - Whether the bigint should have a fixed size.
- * @returns CoderType representing the bigint value.
- * @example
- * const U512BE = P.bigint(64, false, true, true); // Define a CoderType for a 512-bit unsigned big-endian integer
- */
-export const bigint = (size, le = false, signed = false, sized = true) => {
-    if (!isNum(size))
-        throw new Error(`bigint/size: wrong value ${size}`);
-    if (typeof le !== 'boolean')
-        throw new Error(`bigint/le: expected boolean, got ${typeof le}`);
-    if (typeof signed !== 'boolean')
-        throw new Error(`bigint/signed: expected boolean, got ${typeof signed}`);
-    if (typeof sized !== 'boolean')
-        throw new Error(`bigint/sized: expected boolean, got ${typeof sized}`);
-    const bLen = BigInt(size);
-    const signBit = 2n ** (8n * bLen - 1n);
-    return wrap({
-        size: sized ? size : undefined,
-        encodeStream: (w, value) => {
-            if (signed && value < 0)
-                value = value | signBit;
-            const b = [];
-            for (let i = 0; i < size; i++) {
-                b.push(Number(value & 255n));
-                value >>= 8n;
-            }
-            let res = new Uint8Array(b).reverse();
-            if (!sized) {
-                let pos = 0;
-                for (pos = 0; pos < res.length; pos++)
-                    if (res[pos] !== 0)
-                        break;
-                res = res.subarray(pos); // remove leading zeros
-            }
-            w.bytes(le ? res.reverse() : res);
-        },
-        decodeStream: (r) => {
-            // TODO: for le we can read until first zero?
-            const value = r.bytes(sized ? size : Math.min(size, r.leftBytes));
-            const b = le ? value : swapEndianness(value);
-            let res = 0n;
-            for (let i = 0; i < b.length; i++)
-                res |= BigInt(b[i]) << (8n * BigInt(i));
-            if (signed && res & signBit)
-                res = (res ^ signBit) - signBit;
-            return res;
-        },
-        validate: (value) => {
-            if (typeof value !== 'bigint')
-                throw new Error(`bigint: invalid value: ${value}`);
-            checkBounds(value, 8n * bLen, !!signed);
-            return value;
-        },
-    });
-};
-/** Unsigned 256-bit little-endian integer CoderType. */
-export const U256LE = /* @__PURE__ */ bigint(32, true);
-/** Unsigned 256-bit big-endian integer CoderType. */
-export const U256BE = /* @__PURE__ */ bigint(32, false);
-/** Signed 256-bit little-endian integer CoderType. */
-export const I256LE = /* @__PURE__ */ bigint(32, true, true);
-/** Signed 256-bit big-endian integer CoderType. */
-export const I256BE = /* @__PURE__ */ bigint(32, false, true);
-/** Unsigned 128-bit little-endian integer CoderType. */
-export const U128LE = /* @__PURE__ */ bigint(16, true);
-/** Unsigned 128-bit big-endian integer CoderType. */
-export const U128BE = /* @__PURE__ */ bigint(16, false);
-/** Signed 128-bit little-endian integer CoderType. */
-export const I128LE = /* @__PURE__ */ bigint(16, true, true);
-/** Signed 128-bit big-endian integer CoderType. */
-export const I128BE = /* @__PURE__ */ bigint(16, false, true);
-/** Unsigned 64-bit little-endian integer CoderType. */
-export const U64LE = /* @__PURE__ */ bigint(8, true);
-/** Unsigned 64-bit big-endian integer CoderType. */
-export const U64BE = /* @__PURE__ */ bigint(8, false);
-/** Signed 64-bit little-endian integer CoderType. */
-export const I64LE = /* @__PURE__ */ bigint(8, true, true);
-/** Signed 64-bit big-endian integer CoderType. */
-export const I64BE = /* @__PURE__ */ bigint(8, false, true);
-/**
- * CoderType for working with numbber values (up to 6 bytes/48 bits).
- * Unsized int values should be wrapped in a container (e.g., bytes or string).
- *
- * `0 = Uint8Array.of()`
- *
- * `1 = new Uint8Array([1n])`
- *
- * Please open issue, if you need different behavior for zero.
- *
- * @param size - Size of the number in bytes.
- * @param le - Whether to use little-endian byte order.
- * @param signed - Whether the number is signed.
- * @param sized - Whether the number should have a fixed size.
- * @returns CoderType representing the number value.
- * @example
- * const uint64BE = P.bigint(8, false, true); // Define a CoderType for a 64-bit unsigned big-endian integer
- */
-export const int = (size, le = false, signed = false, sized = true) => {
-    if (!isNum(size))
-        throw new Error(`int/size: wrong value ${size}`);
-    if (typeof le !== 'boolean')
-        throw new Error(`int/le: expected boolean, got ${typeof le}`);
-    if (typeof signed !== 'boolean')
-        throw new Error(`int/signed: expected boolean, got ${typeof signed}`);
-    if (typeof sized !== 'boolean')
-        throw new Error(`int/sized: expected boolean, got ${typeof sized}`);
-    if (size > 6)
-        throw new Error('int supports size up to 6 bytes (48 bits): use bigints instead');
-    return apply(bigint(size, le, signed, sized), coders.numberBigint);
-};
-const view = (len, opts) => wrap({
-    size: len,
-    encodeStream: (w, value) => w.writeView(len, (view) => opts.write(view, value)),
-    decodeStream: (r) => r.readView(len, opts.read),
-    validate: (value) => {
-        if (typeof value !== 'number')
-            throw new Error(`viewCoder: expected number, got ${typeof value}`);
-        if (opts.validate)
-            opts.validate(value);
-        return value;
-    },
-});
-const intView = (len, signed, opts) => {
-    const bits = len * 8;
-    const signBit = 2 ** (bits - 1);
-    // Inlined checkBounds for integer
-    const validateSigned = (value) => {
-        if (!isNum(value))
-            throw new Error(`sintView: value is not safe integer: ${value}`);
-        if (value < -signBit || value >= signBit) {
-            throw new Error(`sintView: value out of bounds. Expected ${-signBit} <= ${value} < ${signBit}`);
-        }
-    };
-    const maxVal = 2 ** bits;
-    const validateUnsigned = (value) => {
-        if (!isNum(value))
-            throw new Error(`uintView: value is not safe integer: ${value}`);
-        if (0 > value || value >= maxVal) {
-            throw new Error(`uintView: value out of bounds. Expected 0 <= ${value} < ${maxVal}`);
-        }
-    };
-    return view(len, {
-        write: opts.write,
-        read: opts.read,
-        validate: signed ? validateSigned : validateUnsigned,
-    });
-};
-/** Unsigned 32-bit little-endian integer CoderType. */
-export const U32LE = /* @__PURE__ */ intView(4, false, {
-    read: (view, pos) => view.getUint32(pos, true),
-    write: (view, value) => view.setUint32(0, value, true),
-});
-/** Unsigned 32-bit big-endian integer CoderType. */
-export const U32BE = /* @__PURE__ */ intView(4, false, {
-    read: (view, pos) => view.getUint32(pos, false),
-    write: (view, value) => view.setUint32(0, value, false),
-});
-/** Signed 32-bit little-endian integer CoderType. */
-export const I32LE = /* @__PURE__ */ intView(4, true, {
-    read: (view, pos) => view.getInt32(pos, true),
-    write: (view, value) => view.setInt32(0, value, true),
-});
-/** Signed 32-bit big-endian integer CoderType. */
-export const I32BE = /* @__PURE__ */ intView(4, true, {
-    read: (view, pos) => view.getInt32(pos, false),
-    write: (view, value) => view.setInt32(0, value, false),
-});
-/** Unsigned 16-bit little-endian integer CoderType. */
-export const U16LE = /* @__PURE__ */ intView(2, false, {
-    read: (view, pos) => view.getUint16(pos, true),
-    write: (view, value) => view.setUint16(0, value, true),
-});
-/** Unsigned 16-bit big-endian integer CoderType. */
-export const U16BE = /* @__PURE__ */ intView(2, false, {
-    read: (view, pos) => view.getUint16(pos, false),
-    write: (view, value) => view.setUint16(0, value, false),
-});
-/** Signed 16-bit little-endian integer CoderType. */
-export const I16LE = /* @__PURE__ */ intView(2, true, {
-    read: (view, pos) => view.getInt16(pos, true),
-    write: (view, value) => view.setInt16(0, value, true),
-});
-/** Signed 16-bit big-endian integer CoderType. */
-export const I16BE = /* @__PURE__ */ intView(2, true, {
-    read: (view, pos) => view.getInt16(pos, false),
-    write: (view, value) => view.setInt16(0, value, false),
-});
-/** Unsigned 8-bit integer CoderType. */
-export const U8 = /* @__PURE__ */ intView(1, false, {
-    read: (view, pos) => view.getUint8(pos),
-    write: (view, value) => view.setUint8(0, value),
-});
-/** Signed 8-bit integer CoderType. */
-export const I8 = /* @__PURE__ */ intView(1, true, {
-    read: (view, pos) => view.getInt8(pos),
-    write: (view, value) => view.setInt8(0, value),
-});
-// Floats
-const f32 = (le) => view(4, {
-    read: (view, pos) => view.getFloat32(pos, le),
-    write: (view, value) => view.setFloat32(0, value, le),
-    validate: (value) => {
-        if (Math.fround(value) !== value && !Number.isNaN(value))
-            throw new Error(`f32: wrong value=${value}`);
-    },
-});
-const f64 = (le) => view(8, {
-    read: (view, pos) => view.getFloat64(pos, le),
-    write: (view, value) => view.setFloat64(0, value, le),
-});
-/** 32-bit big-endian floating point CoderType ("binary32", IEEE 754-2008). */
-export const F32BE = /* @__PURE__ */ f32(false);
-/** 32-bit little-endian floating point  CoderType ("binary32", IEEE 754-2008). */
-export const F32LE = /* @__PURE__ */ f32(true);
-/** A 64-bit big-endian floating point type ("binary64", IEEE 754-2008). Any JS number can be encoded. */
-export const F64BE = /* @__PURE__ */ f64(false);
-/** A 64-bit little-endian floating point type ("binary64", IEEE 754-2008). Any JS number can be encoded. */
-export const F64LE = /* @__PURE__ */ f64(true);
-/** Boolean CoderType. */
-export const bool = /* @__PURE__ */ wrap({
-    size: 1,
-    encodeStream: (w, value) => w.byte(value ? 1 : 0),
-    decodeStream: (r) => {
-        const value = r.byte();
-        if (value !== 0 && value !== 1)
-            throw r.err(`bool: invalid value ${value}`);
-        return value === 1;
-    },
-    validate: (value) => {
-        if (typeof value !== 'boolean')
-            throw new Error(`bool: invalid value ${value}`);
-        return value;
-    },
-});
-/**
- * Bytes CoderType with a specified length and endianness.
- * The bytes can have:
- * - Dynamic size (prefixed with a length CoderType like U16BE)
- * - Fixed size (specified by a number)
- * - Unknown size (null, will parse until end of buffer)
- * - Zero-terminated (terminator can be any Uint8Array)
- * @param len - CoderType, number, Uint8Array (terminator) or null
- * @param le - Whether to use little-endian byte order.
- * @returns CoderType representing the bytes.
- * @example
- * // Dynamic size bytes (prefixed with P.U16BE number of bytes length)
- * const dynamicBytes = P.bytes(P.U16BE, false);
- * const fixedBytes = P.bytes(32, false); // Fixed size bytes
- * const unknownBytes = P.bytes(null, false); // Unknown size bytes, will parse until end of buffer
- * const zeroTerminatedBytes = P.bytes(Uint8Array.of(0), false); // Zero-terminated bytes
- */
-const createBytes = (len, le = false) => {
-    if (typeof le !== 'boolean')
-        throw new Error(`bytes/le: expected boolean, got ${typeof le}`);
-    const _length = lengthCoder(len);
-    const _isb = isBytes(len);
-    return wrap({
-        size: typeof len === 'number' ? len : undefined,
-        encodeStream: (w, value) => {
-            if (!_isb)
-                _length.encodeStream(w, value.length);
-            w.bytes(le ? swapEndianness(value) : value);
-            if (_isb)
-                w.bytes(len);
-        },
-        decodeStream: (r) => {
-            let bytes;
-            if (_isb) {
-                const tPos = r.find(len);
-                if (!tPos)
-                    throw r.err(`bytes: cannot find terminator`);
-                bytes = r.bytes(tPos - r.pos);
-                r.bytes(len.length);
-            }
-            else {
-                bytes = r.bytes(len === null ? r.leftBytes : _length.decodeStream(r));
-            }
-            return le ? swapEndianness(bytes) : bytes;
-        },
-        validate: (value) => {
-            if (!isBytes(value))
-                throw new Error(`bytes: invalid value ${value}`);
-            return value;
-        },
-    });
-};
-export { createBytes as bytes, createHex as hex };
-/**
- * Prefix-encoded value using a length prefix and an inner CoderType.
- * The prefix can have:
- * - Dynamic size (prefixed with a length CoderType like U16BE)
- * - Fixed size (specified by a number)
- * - Unknown size (null, will parse until end of buffer)
- * - Zero-terminated (terminator can be any Uint8Array)
- * @param len - Length CoderType (dynamic size), number (fixed size), Uint8Array (for terminator), or null (will parse until end of buffer)
- * @param inner - CoderType for the actual value to be prefix-encoded.
- * @returns CoderType representing the prefix-encoded value.
- * @example
- * const dynamicPrefix = P.prefix(P.U16BE, P.bytes(null)); // Dynamic size prefix (prefixed with P.U16BE number of bytes length)
- * const fixedPrefix = P.prefix(10, P.bytes(null)); // Fixed size prefix (always 10 bytes)
- */
-export function prefix(len, inner) {
-    if (!isCoder(inner))
-        throw new Error(`prefix: invalid inner value ${inner}`);
-    return apply(createBytes(len), reverse(inner));
-}
-/**
- * String CoderType with a specified length and endianness.
- * The string can be:
- * - Dynamic size (prefixed with a length CoderType like U16BE)
- * - Fixed size (specified by a number)
- * - Unknown size (null, will parse until end of buffer)
- * - Zero-terminated (terminator can be any Uint8Array)
- * @param len - Length CoderType (dynamic size), number (fixed size), Uint8Array (for terminator), or null (will parse until end of buffer)
- * @param le - Whether to use little-endian byte order.
- * @returns CoderType representing the string.
- * @example
- * const dynamicString = P.string(P.U16BE, false); // Dynamic size string (prefixed with P.U16BE number of string length)
- * const fixedString = P.string(10, false); // Fixed size string
- * const unknownString = P.string(null, false); // Unknown size string, will parse until end of buffer
- * const nullTerminatedString = P.cstring; // NUL-terminated string
- * const _cstring = P.string(Uint8Array.of(0)); // Same thing
- */
-export const string = (len, le = false) => validate(apply(createBytes(len, le), utf8), (value) => {
-    // TextEncoder/TextDecoder will fail on non-string, but we create more readable errors earlier
-    if (typeof value !== 'string')
-        throw new Error(`expected string, got ${typeof value}`);
-    return value;
-});
-/** NUL-terminated string CoderType. */
-export const cstring = /* @__PURE__ */ string(NULL);
-/**
- * Hexadecimal string CoderType with a specified length, endianness, and optional 0x prefix.
- * @param len - Length CoderType (dynamic size), number (fixed size), Uint8Array (for terminator), or null (will parse until end of buffer)
- * @param le - Whether to use little-endian byte order.
- * @param withZero - Whether to include the 0x prefix.
- * @returns CoderType representing the hexadecimal string.
- * @example
- * const dynamicHex = P.hex(P.U16BE, {isLE: false, with0x: true}); // Hex string with 0x prefix and U16BE length
- * const fixedHex = P.hex(32, {isLE: false, with0x: false}); // Fixed-length 32-byte hex string without 0x prefix
- */
-const createHex = (len, options = { isLE: false, with0x: false }) => {
-    let inner = apply(createBytes(len, options.isLE), baseHex);
-    const prefix = options.with0x;
-    if (typeof prefix !== 'boolean')
-        throw new Error(`hex/with0x: expected boolean, got ${typeof prefix}`);
-    if (prefix) {
-        inner = apply(inner, {
-            encode: (value) => `0x${value}`,
-            decode: (value) => {
-                if (!value.startsWith('0x'))
-                    throw new Error('hex(with0x=true).encode input should start with 0x');
-                return value.slice(2);
-            },
-        });
-    }
-    return inner;
-};
-/**
- * Applies a base coder to a CoderType.
- * @param inner - The inner CoderType.
- * @param b - The base coder to apply.
- * @returns CoderType representing the transformed value.
- * @example
- * import { hex } from '@scure/base';
- * const hex = P.apply(P.bytes(32), hex); // will decode bytes into a hex string
- */
-export function apply(inner, base) {
-    if (!isCoder(inner))
-        throw new Error(`apply: invalid inner value ${inner}`);
-    if (!isBaseCoder(base))
-        throw new Error(`apply: invalid base value ${inner}`);
-    return wrap({
-        size: inner.size,
-        encodeStream: (w, value) => {
-            let innerValue;
-            try {
-                innerValue = base.decode(value);
-            }
-            catch (e) {
-                throw w.err('' + e);
-            }
-            return inner.encodeStream(w, innerValue);
-        },
-        decodeStream: (r) => {
-            const innerValue = inner.decodeStream(r);
-            try {
-                return base.encode(innerValue);
-            }
-            catch (e) {
-                throw r.err('' + e);
-            }
-        },
-    });
-}
-/**
- * Lazy CoderType that is evaluated at runtime.
- * @param fn - A function that returns the CoderType.
- * @returns CoderType representing the lazy value.
- * @example
- * type Tree = { name: string; children: Tree[] };
- * const tree = P.struct({
- *   name: P.cstring,
- *   children: P.array(
- *     P.U16BE,
- *     P.lazy((): P.CoderType<Tree> => tree)
- *   ),
- * });
- */
-export function lazy(fn) {
-    if (typeof fn !== 'function')
-        throw new Error(`lazy: expected function, got ${typeof fn}`);
-    return wrap({
-        encodeStream: (w, value) => fn().encodeStream(w, value),
-        decodeStream: (r) => fn().decodeStream(r),
-    });
-}
-/**
- * Flag CoderType that encodes/decodes a boolean value based on the presence of a marker.
- * @param flagValue - Marker value.
- * @param xor - Whether to invert the flag behavior.
- * @returns CoderType representing the flag value.
- * @example
- * const flag = P.flag(new Uint8Array([0x01, 0x02])); // Encodes true as u8a([0x01, 0x02]), false as u8a([])
- * const flagXor = P.flag(new Uint8Array([0x01, 0x02]), true); // Encodes true as u8a([]), false as u8a([0x01, 0x02])
- * // Conditional encoding with flagged
- * const s = P.struct({ f: P.flag(new Uint8Array([0x0, 0x1])), f2: P.flagged('f', P.U32BE) });
- */
-export const flag = (flagValue, xor = false) => {
-    if (!isBytes(flagValue))
-        throw new Error(`flag/flagValue: expected Uint8Array, got ${typeof flagValue}`);
-    if (typeof xor !== 'boolean')
-        throw new Error(`flag/xor: expected boolean, got ${typeof xor}`);
-    return wrap({
-        size: flagValue.length,
-        encodeStream: (w, value) => {
-            if (!!value !== xor)
-                w.bytes(flagValue);
-        },
-        decodeStream: (r) => {
-            let hasFlag = r.leftBytes >= flagValue.length;
-            if (hasFlag) {
-                hasFlag = equalBytes(r.bytes(flagValue.length, true), flagValue);
-                // Found flag, advance cursor position
-                if (hasFlag)
-                    r.bytes(flagValue.length);
-            }
-            return hasFlag !== xor; // hasFlag ^ xor
-        },
-        validate: (value) => {
-            if (value !== undefined && typeof value !== 'boolean')
-                throw new Error(`flag: expected boolean value or undefined, got ${typeof value}`);
-            return value;
-        },
-    });
-};
-/**
- * Conditional CoderType that encodes/decodes a value only if a flag is present.
- * @param path - Path to the flag value or a CoderType for the flag.
- * @param inner - Inner CoderType for the value.
- * @param def - Optional default value to use if the flag is not present.
- * @returns CoderType representing the conditional value.
- * @example
- * const s = P.struct({
- *   f: P.flag(new Uint8Array([0x0, 0x1])),
- *   f2: P.flagged('f', P.U32BE)
- * });
- *
- * @example
- * const s2 = P.struct({
- *   f: P.flag(new Uint8Array([0x0, 0x1])),
- *   f2: P.flagged('f', P.U32BE, 123)
- * });
- */
-export function flagged(path, inner, def) {
-    if (!isCoder(inner))
-        throw new Error(`flagged: invalid inner value ${inner}`);
-    if (typeof path !== 'string' && !isCoder(inner))
-        throw new Error(`flagged: wrong path=${path}`);
-    return wrap({
-        encodeStream: (w, value) => {
-            if (typeof path === 'string') {
-                if (Path.resolve(w.stack, path))
-                    inner.encodeStream(w, value);
-                else if (def)
-                    inner.encodeStream(w, def);
-            }
-            else {
-                path.encodeStream(w, !!value);
-                if (!!value)
-                    inner.encodeStream(w, value);
-                else if (def)
-                    inner.encodeStream(w, def);
-            }
-        },
-        decodeStream: (r) => {
-            let hasFlag = false;
-            if (typeof path === 'string')
-                hasFlag = !!Path.resolve(r.stack, path);
-            else
-                hasFlag = path.decodeStream(r);
-            // If there is a flag -- decode and return value
-            if (hasFlag)
-                return inner.decodeStream(r);
-            else if (def)
-                inner.decodeStream(r);
-            return;
-        },
-    });
-}
-/**
- * Optional CoderType that encodes/decodes a value based on a flag.
- * @param flag - CoderType for the flag value.
- * @param inner - Inner CoderType for the value.
- * @param def - Optional default value to use if the flag is not present.
- * @returns CoderType representing the optional value.
- * @example
- * // Will decode into P.U32BE only if flag present
- * const optional = P.optional(P.flag(new Uint8Array([0x0, 0x1])), P.U32BE);
- *
- * @example
- * // If no flag present, will decode into default value
- * const optionalWithDefault = P.optional(P.flag(new Uint8Array([0x0, 0x1])), P.U32BE, 123);
- */
-export function optional(flag, inner, def) {
-    if (!isCoder(flag) || !isCoder(inner))
-        throw new Error(`optional: invalid flag or inner value flag=${flag} inner=${inner}`);
-    return wrap({
-        size: def !== undefined && flag.size && inner.size ? flag.size + inner.size : undefined,
-        encodeStream: (w, value) => {
-            flag.encodeStream(w, !!value);
-            if (value)
-                inner.encodeStream(w, value);
-            else if (def !== undefined)
-                inner.encodeStream(w, def);
-        },
-        decodeStream: (r) => {
-            if (flag.decodeStream(r))
-                return inner.decodeStream(r);
-            else if (def !== undefined)
-                inner.decodeStream(r);
-            return;
-        },
-    });
-}
-/**
- * Magic value CoderType that encodes/decodes a constant value.
- * This can be used to check for a specific magic value or sequence of bytes at the beginning of a data structure.
- * @param inner - Inner CoderType for the value.
- * @param constant - Constant value.
- * @param check - Whether to check the decoded value against the constant.
- * @returns CoderType representing the magic value.
- * @example
- * // Always encodes constant as bytes using inner CoderType, throws if encoded value is not present
- * const magicU8 = P.magic(P.U8, 0x42);
- */
-export function magic(inner, constant, check = true) {
-    if (!isCoder(inner))
-        throw new Error(`magic: invalid inner value ${inner}`);
-    if (typeof check !== 'boolean')
-        throw new Error(`magic: expected boolean, got ${typeof check}`);
-    return wrap({
-        size: inner.size,
-        encodeStream: (w, _value) => inner.encodeStream(w, constant),
-        decodeStream: (r) => {
-            const value = inner.decodeStream(r);
-            if ((check && typeof value !== 'object' && value !== constant) ||
-                (isBytes(constant) && !equalBytes(constant, value))) {
-                throw r.err(`magic: invalid value: ${value} !== ${constant}`);
-            }
-            return;
-        },
-        validate: (value) => {
-            if (value !== undefined)
-                throw new Error(`magic: wrong value=${typeof value}`);
-            return value;
-        },
-    });
-}
-/**
- * Magic bytes CoderType that encodes/decodes a constant byte array or string.
- * @param constant - Constant byte array or string.
- * @returns CoderType representing the magic bytes.
- * @example
- * // Always encodes undefined into byte representation of string 'MAGIC'
- * const magicBytes = P.magicBytes('MAGIC');
- */
-export const magicBytes = (constant) => {
-    const c = typeof constant === 'string' ? utf8.decode(constant) : constant;
-    return magic(createBytes(c.length), c);
-};
-/**
- * Creates a CoderType for a constant value. The function enforces this value during encoding,
- * ensuring it matches the provided constant. During decoding, it always returns the constant value.
- * The actual value is not written to or read from any byte stream; it's used only for validation.
- *
- * @param c - Constant value.
- * @returns CoderType representing the constant value.
- * @example
- * // Always return 123 on decode, throws on encoding anything other than 123
- * const constantU8 = P.constant(123);
- */
-export function constant(c) {
-    return wrap({
-        encodeStream: (_w, value) => {
-            if (value !== c)
-                throw new Error(`constant: invalid value ${value} (exp: ${c})`);
-        },
-        decodeStream: (_r) => c,
-    });
-}
-function sizeof(fields) {
-    let size = 0;
-    for (const f of fields) {
-        if (f.size === undefined)
-            return;
-        if (!isNum(f.size))
-            throw new Error(`sizeof: wrong element size=${size}`);
-        size += f.size;
-    }
-    return size;
-}
-/**
- * Structure of composable primitives (C/Rust struct)
- * @param fields - Object mapping field names to CoderTypes.
- * @returns CoderType representing the structure.
- * @example
- * // Define a structure with a 32-bit big-endian unsigned integer, a string, and a nested structure
- * const myStruct = P.struct({
- *   id: P.U32BE,
- *   name: P.string(P.U8),
- *   nested: P.struct({
- *     flag: P.bool,
- *     value: P.I16LE
- *   })
- * });
- */
-export function struct(fields) {
-    if (!isPlainObject(fields))
-        throw new Error(`struct: expected plain object, got ${fields}`);
-    for (const name in fields) {
-        if (!isCoder(fields[name]))
-            throw new Error(`struct: field ${name} is not CoderType`);
-    }
-    return wrap({
-        size: sizeof(Object.values(fields)),
-        encodeStream: (w, value) => {
-            w.pushObj(value, (fieldFn) => {
-                for (const name in fields)
-                    fieldFn(name, () => fields[name].encodeStream(w, value[name]));
-            });
-        },
-        decodeStream: (r) => {
-            const res = {};
-            r.pushObj(res, (fieldFn) => {
-                for (const name in fields)
-                    fieldFn(name, () => (res[name] = fields[name].decodeStream(r)));
-            });
-            return res;
-        },
-        validate: (value) => {
-            if (typeof value !== 'object' || value === null)
-                throw new Error(`struct: invalid value ${value}`);
-            return value;
-        },
-    });
-}
-/**
- * Tuple (unnamed structure) of CoderTypes. Same as struct but with unnamed fields.
- * @param fields - Array of CoderTypes.
- * @returns CoderType representing the tuple.
- * @example
- * const myTuple = P.tuple([P.U8, P.U16LE, P.string(P.U8)]);
- */
-export function tuple(fields) {
-    if (!Array.isArray(fields))
-        throw new Error(`Packed.Tuple: got ${typeof fields} instead of array`);
-    for (let i = 0; i < fields.length; i++) {
-        if (!isCoder(fields[i]))
-            throw new Error(`tuple: field ${i} is not CoderType`);
-    }
-    return wrap({
-        size: sizeof(fields),
-        encodeStream: (w, value) => {
-            // TODO: fix types
-            if (!Array.isArray(value))
-                throw w.err(`tuple: invalid value ${value}`);
-            w.pushObj(value, (fieldFn) => {
-                for (let i = 0; i < fields.length; i++)
-                    fieldFn(`${i}`, () => fields[i].encodeStream(w, value[i]));
-            });
-        },
-        decodeStream: (r) => {
-            const res = [];
-            r.pushObj(res, (fieldFn) => {
-                for (let i = 0; i < fields.length; i++)
-                    fieldFn(`${i}`, () => res.push(fields[i].decodeStream(r)));
-            });
-            return res;
-        },
-        validate: (value) => {
-            if (!Array.isArray(value))
-                throw new Error(`tuple: invalid value ${value}`);
-            if (value.length !== fields.length)
-                throw new Error(`tuple: wrong length=${value.length}, expected ${fields.length}`);
-            return value;
-        },
-    });
-}
-/**
- * Array of items (inner type) with a specified length.
- * @param len - Length CoderType (dynamic size), number (fixed size), Uint8Array (for terminator), or null (will parse until end of buffer)
- * @param inner - CoderType for encoding/decoding each array item.
- * @returns CoderType representing the array.
- * @example
- * const a1 = P.array(P.U16BE, child); // Dynamic size array (prefixed with P.U16BE number of array length)
- * const a2 = P.array(4, child); // Fixed size array
- * const a3 = P.array(null, child); // Unknown size array, will parse until end of buffer
- * const a4 = P.array(Uint8Array.of(0), child); // zero-terminated array (NOTE: terminator can be any buffer)
- */
-export function array(len, inner) {
-    if (!isCoder(inner))
-        throw new Error(`array: invalid inner value ${inner}`);
-    // By construction length is inside array (otherwise there will be various incorrect stack states)
-    // But forcing users always write '..' seems like bad idea. Also, breaking change.
-    const _length = lengthCoder(typeof len === 'string' ? `../${len}` : len);
-    return wrap({
-        size: typeof len === 'number' && inner.size ? len * inner.size : undefined,
-        encodeStream: (w, value) => {
-            const _w = w;
-            _w.pushObj(value, (fieldFn) => {
-                if (!isBytes(len))
-                    _length.encodeStream(w, value.length);
-                for (let i = 0; i < value.length; i++) {
-                    fieldFn(`${i}`, () => {
-                        const elm = value[i];
-                        const startPos = w.pos;
-                        inner.encodeStream(w, elm);
-                        if (isBytes(len)) {
-                            // Terminator is bigger than elm size, so skip
-                            if (len.length > _w.pos - startPos)
-                                return;
-                            const data = _w.finish(false).subarray(startPos, _w.pos);
-                            // There is still possible case when multiple elements create terminator,
-                            // but it is hard to catch here, will be very slow
-                            if (equalBytes(data.subarray(0, len.length), len))
-                                throw _w.err(`array: inner element encoding same as separator. elm=${elm} data=${data}`);
-                        }
-                    });
-                }
-            });
-            if (isBytes(len))
-                w.bytes(len);
-        },
-        decodeStream: (r) => {
-            const res = [];
-            r.pushObj(res, (fieldFn) => {
-                if (len === null) {
-                    for (let i = 0; !r.isEnd(); i++) {
-                        fieldFn(`${i}`, () => res.push(inner.decodeStream(r)));
-                        if (inner.size && r.leftBytes < inner.size)
-                            break;
-                    }
-                }
-                else if (isBytes(len)) {
-                    for (let i = 0;; i++) {
-                        if (equalBytes(r.bytes(len.length, true), len)) {
-                            // Advance cursor position if terminator found
-                            r.bytes(len.length);
-                            break;
-                        }
-                        fieldFn(`${i}`, () => res.push(inner.decodeStream(r)));
-                    }
-                }
-                else {
-                    let length;
-                    fieldFn('arrayLen', () => (length = _length.decodeStream(r)));
-                    for (let i = 0; i < length; i++)
-                        fieldFn(`${i}`, () => res.push(inner.decodeStream(r)));
-                }
-            });
-            return res;
-        },
-        validate: (value) => {
-            if (!Array.isArray(value))
-                throw new Error(`array: invalid value ${value}`);
-            return value;
-        },
-    });
-}
-/**
- * Mapping between encoded values and string representations.
- * @param inner - CoderType for encoded values.
- * @param variants - Object mapping string representations to encoded values.
- * @returns CoderType representing the mapping.
- * @example
- * // Map between numbers and strings
- * const numberMap = P.map(P.U8, {
- *   'one': 1,
- *   'two': 2,
- *   'three': 3
- * });
- *
- * // Map between byte arrays and strings
- * const byteMap = P.map(P.bytes(2, false), {
- *   'ab': Uint8Array.from([0x61, 0x62]),
- *   'cd': Uint8Array.from([0x63, 0x64])
- * });
- */
-export function map(inner, variants) {
-    if (!isCoder(inner))
-        throw new Error(`map: invalid inner value ${inner}`);
-    if (!isPlainObject(variants))
-        throw new Error(`map: variants should be plain object`);
-    const variantNames = new Map();
-    for (const k in variants)
-        variantNames.set(variants[k], k);
-    return wrap({
-        size: inner.size,
-        encodeStream: (w, value) => inner.encodeStream(w, variants[value]),
-        decodeStream: (r) => {
-            const variant = inner.decodeStream(r);
-            const name = variantNames.get(variant);
-            if (name === undefined)
-                throw r.err(`Enum: unknown value: ${variant} ${Array.from(variantNames.keys())}`);
-            return name;
-        },
-        validate: (value) => {
-            if (typeof value !== 'string')
-                throw new Error(`map: invalid value ${value}`);
-            if (!(value in variants))
-                throw new Error(`Map: unknown variant: ${value}`);
-            return value;
-        },
-    });
-}
-/**
- * Tagged union of CoderTypes, where the tag value determines which CoderType to use.
- * The decoded value will have the structure `{ TAG: number, data: ... }`.
- * @param tag - CoderType for the tag value.
- * @param variants - Object mapping tag values to CoderTypes.
- * @returns CoderType representing the tagged union.
- * @example
- * // Tagged union of array, string, and number
- * // Depending on the value of the first byte, it will be decoded as an array, string, or number.
- * const taggedUnion = P.tag(P.U8, {
- *   0x01: P.array(P.U16LE, P.U8),
- *   0x02: P.string(P.U8),
- *   0x03: P.U32BE
- * });
- *
- * const encoded = taggedUnion.encode({ TAG: 0x01, data: 'hello' }); // Encodes the string 'hello' with tag 0x01
- * const decoded = taggedUnion.decode(encoded); // Decodes the encoded value back to { TAG: 0x01, data: 'hello' }
- */
-export function tag(tag, variants) {
-    if (!isCoder(tag))
-        throw new Error(`tag: invalid tag value ${tag}`);
-    if (!isPlainObject(variants))
-        throw new Error(`tag: variants should be plain object`);
-    for (const name in variants) {
-        if (!isCoder(variants[name]))
-            throw new Error(`tag: variant ${name} is not CoderType`);
-    }
-    return wrap({
-        size: tag.size,
-        encodeStream: (w, value) => {
-            const { TAG, data } = value;
-            const dataType = variants[TAG];
-            tag.encodeStream(w, TAG);
-            dataType.encodeStream(w, data);
-        },
-        decodeStream: (r) => {
-            const TAG = tag.decodeStream(r);
-            const dataType = variants[TAG];
-            if (!dataType)
-                throw r.err(`Tag: invalid tag ${TAG}`);
-            return { TAG, data: dataType.decodeStream(r) };
-        },
-        validate: (value) => {
-            const { TAG } = value;
-            const dataType = variants[TAG];
-            if (!dataType)
-                throw new Error(`Tag: invalid tag ${TAG.toString()}`);
-            return value;
-        },
-    });
-}
-/**
- * Mapping between encoded values, string representations, and CoderTypes using a tag CoderType.
- * @param tagCoder - CoderType for the tag value.
- * @param variants - Object mapping string representations to [tag value, CoderType] pairs.
- *  * @returns CoderType representing the mapping.
- * @example
- * const cborValue: P.CoderType<CborValue> = P.mappedTag(P.bits(3), {
- *   uint: [0, cborUint], // An unsigned integer in the range 0..264-1 inclusive.
- *   negint: [1, cborNegint], // A negative integer in the range -264..-1 inclusive
- *   bytes: [2, P.lazy(() => cborLength(P.bytes, cborValue))], // A byte string.
- *   string: [3, P.lazy(() => cborLength(P.string, cborValue))], // A text string (utf8)
- *   array: [4, cborArrLength(P.lazy(() => cborValue))], // An array of data items
- *   map: [5, P.lazy(() => cborArrLength(P.tuple([cborValue, cborValue])))], // A map of pairs of data items
- *   tag: [6, P.tuple([cborUint, P.lazy(() => cborValue)] as const)], // A tagged data item ("tag") whose tag number
- *   simple: [7, cborSimple], // Floating-point numbers and simple values, as well as the "break" stop code
- * });
- */
-export function mappedTag(tagCoder, variants) {
-    if (!isCoder(tagCoder))
-        throw new Error(`mappedTag: invalid tag value ${tag}`);
-    if (!isPlainObject(variants))
-        throw new Error(`mappedTag: variants should be plain object`);
-    const mapValue = {};
-    const tagValue = {};
-    for (const key in variants) {
-        const v = variants[key];
-        mapValue[key] = v[0];
-        tagValue[key] = v[1];
-    }
-    return tag(map(tagCoder, mapValue), tagValue);
-}
-/**
- * Bitset of boolean values with optional padding.
- * @param names - An array of string names for the bitset values.
- * @param pad - Whether to pad the bitset to a multiple of 8 bits.
- * @returns CoderType representing the bitset.
- * @template Names
- * @example
- * const myBitset = P.bitset(['flag1', 'flag2', 'flag3', 'flag4'], true);
- */
-export function bitset(names, pad = false) {
-    if (typeof pad !== 'boolean')
-        throw new Error(`bitset/pad: expected boolean, got ${typeof pad}`);
-    if (!Array.isArray(names))
-        throw new Error('bitset/names: expected array');
-    for (const name of names) {
-        if (typeof name !== 'string')
-            throw new Error('bitset/names: expected array of strings');
-    }
-    return wrap({
-        encodeStream: (w, value) => {
-            for (let i = 0; i < names.length; i++)
-                w.bits(+value[names[i]], 1);
-            if (pad && names.length % 8)
-                w.bits(0, 8 - (names.length % 8));
-        },
-        decodeStream: (r) => {
-            const out = {};
-            for (let i = 0; i < names.length; i++)
-                out[names[i]] = !!r.bits(1);
-            if (pad && names.length % 8)
-                r.bits(8 - (names.length % 8));
-            return out;
-        },
-        validate: (value) => {
-            if (!isPlainObject(value))
-                throw new Error(`bitset: invalid value ${value}`);
-            for (const v of Object.values(value)) {
-                if (typeof v !== 'boolean')
-                    throw new Error('expected boolean');
-            }
-            return value;
-        },
-    });
-}
-/** Padding function which always returns zero */
-export const ZeroPad = (_) => 0;
-function padLength(blockSize, len) {
-    if (len % blockSize === 0)
-        return 0;
-    return blockSize - (len % blockSize);
-}
-/**
- * Pads a CoderType with a specified block size and padding function on the left side.
- * @param blockSize - Block size for padding (positive safe integer).
- * @param inner - Inner CoderType to pad.
- * @param padFn - Padding function to use. If not provided, zero padding is used.
- * @returns CoderType representing the padded value.
- * @example
- * // Pad a U32BE with a block size of 4 and zero padding
- * const paddedU32BE = P.padLeft(4, P.U32BE);
- *
- * // Pad a string with a block size of 16 and custom padding
- * const paddedString = P.padLeft(16, P.string(P.U8), (i) => i + 1);
- */
-export function padLeft(blockSize, inner, padFn) {
-    if (!isNum(blockSize) || blockSize <= 0)
-        throw new Error(`padLeft: wrong blockSize=${blockSize}`);
-    if (!isCoder(inner))
-        throw new Error(`padLeft: invalid inner value ${inner}`);
-    if (padFn !== undefined && typeof padFn !== 'function')
-        throw new Error(`padLeft: wrong padFn=${typeof padFn}`);
-    const _padFn = padFn || ZeroPad;
-    if (!inner.size)
-        throw new Error('padLeft cannot have dynamic size');
-    return wrap({
-        size: inner.size + padLength(blockSize, inner.size),
-        encodeStream: (w, value) => {
-            const padBytes = padLength(blockSize, inner.size);
-            for (let i = 0; i < padBytes; i++)
-                w.byte(_padFn(i));
-            inner.encodeStream(w, value);
-        },
-        decodeStream: (r) => {
-            r.bytes(padLength(blockSize, inner.size));
-            return inner.decodeStream(r);
-        },
-    });
-}
-/**
- * Pads a CoderType with a specified block size and padding function on the right side.
- * @param blockSize - Block size for padding (positive safe integer).
- * @param inner - Inner CoderType to pad.
- * @param padFn - Padding function to use. If not provided, zero padding is used.
- * @returns CoderType representing the padded value.
- * @example
- * // Pad a U16BE with a block size of 2 and zero padding
- * const paddedU16BE = P.padRight(2, P.U16BE);
- *
- * // Pad a bytes with a block size of 8 and custom padding
- * const paddedBytes = P.padRight(8, P.bytes(null), (i) => i + 1);
- */
-export function padRight(blockSize, inner, padFn) {
-    if (!isCoder(inner))
-        throw new Error(`padRight: invalid inner value ${inner}`);
-    if (!isNum(blockSize) || blockSize <= 0)
-        throw new Error(`padLeft: wrong blockSize=${blockSize}`);
-    if (padFn !== undefined && typeof padFn !== 'function')
-        throw new Error(`padRight: wrong padFn=${typeof padFn}`);
-    const _padFn = padFn || ZeroPad;
-    return wrap({
-        size: inner.size ? inner.size + padLength(blockSize, inner.size) : undefined,
-        encodeStream: (w, value) => {
-            const _w = w;
-            const pos = _w.pos;
-            inner.encodeStream(w, value);
-            const padBytes = padLength(blockSize, _w.pos - pos);
-            for (let i = 0; i < padBytes; i++)
-                w.byte(_padFn(i));
-        },
-        decodeStream: (r) => {
-            const start = r.pos;
-            const res = inner.decodeStream(r);
-            r.bytes(padLength(blockSize, r.pos - start));
-            return res;
-        },
-    });
-}
-1;
-/**
- * Pointer to a value using a pointer CoderType and an inner CoderType.
- * Pointers are scoped, and the next pointer in the dereference chain is offset by the previous one.
- * By default (if no 'allowMultipleReads' in ReaderOpts is set) is safe, since
- * same region of memory cannot be read multiple times.
- * @param ptr - CoderType for the pointer value.
- * @param inner - CoderType for encoding/decoding the pointed value.
- * @param sized - Whether the pointer should have a fixed size.
- * @returns CoderType representing the pointer to the value.
- * @example
- * const pointerToU8 = P.pointer(P.U16BE, P.U8); // Pointer to a single U8 value
- */
-export function pointer(ptr, inner, sized = false) {
-    if (!isCoder(ptr))
-        throw new Error(`pointer: invalid ptr value ${ptr}`);
-    if (!isCoder(inner))
-        throw new Error(`pointer: invalid inner value ${inner}`);
-    if (typeof sized !== 'boolean')
-        throw new Error(`pointer/sized: expected boolean, got ${typeof sized}`);
-    if (!ptr.size)
-        throw new Error('unsized pointer');
-    return wrap({
-        size: sized ? ptr.size : undefined,
-        encodeStream: (w, value) => {
-            const _w = w;
-            const start = _w.pos;
-            ptr.encodeStream(w, 0);
-            _w.ptrs.push({ pos: start, ptr, buffer: inner.encode(value) });
-        },
-        decodeStream: (r) => {
-            const ptrVal = ptr.decodeStream(r);
-            r._enablePointers();
-            return inner.decodeStream(r.offsetReader(ptrVal));
-        },
-    });
-}
-// Internal methods for test purposes only
-export const _TEST = { _bitset: Bitset, _Reader, _Writer, Path };
-//# sourceMappingURL=index.js.map