@isopodlabs/binary_libs 0.0.1 → 0.1.1

package/dist/binary.js

@@ -1,802 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.field = exports.withNames = exports.RemainingArrayType = exports.ArrayType = exports.writen = exports.readn = exports.RemainingStringType = exports.NullTerminatedStringType = exports.StringType = exports.ULEB128 = exports.Float64 = exports.Float32 = exports.Float64_BE = exports.Float64_LE = exports.Float32_BE = exports.Float32_LE = exports.INT = exports.UINT = exports.INT64 = exports.INT64_BE = exports.INT64_LE = exports.UINT64 = exports.UINT64_BE = exports.UINT64_LE = exports.INT32 = exports.UINT32 = exports.INT32_BE = exports.INT32_LE = exports.UINT32_BE = exports.UINT32_LE = exports.INT16 = exports.UINT16 = exports.INT16_BE = exports.INT16_LE = exports.UINT16_BE = exports.UINT16_LE = exports.INT8 = exports.UINT8 = exports.dummy = exports.stream_grow = exports.stream = exports.write = exports.read_more = exports.read = exports.isType = exports.isWriter = exports.isReader = exports.ReadWriteStruct = exports.ReadStruct = exports.utils = void 0;
-exports.stream_endian = exports.asFixed = exports.asInt = exports.asFlags = exports.asEnum = exports.BitFields = exports.Flags = exports.Enum = exports.EnumV = exports.XINT64_LE = exports.XINT32_LE = exports.XINT16_LE = exports.XINT64 = exports.XINT32 = exports.XINT16 = exports.hex = exports.Switch = exports.Optional = exports.If = exports.FuncType = exports.Func = exports.Const = exports.as = exports.MaybeOffsetType = exports.OffsetType = exports.SizeType = exports.DontRead = exports.Discard = exports.AlignType = exports.SkipType = exports.Buffer = exports.Remainder = exports.Struct = exports.objectWithNames = exports.arrayWithNames = exports.names = void 0;
-const utils = __importStar(require("./binary_helpers"));
-exports.utils = __importStar(require("./binary_helpers"));
-function ReadStruct(spec) {
-    return class ReadStruct {
-        static get(s) {
-            return new this(s);
-        }
-        constructor(s) {
-            return Object.assign(this, read(s, spec));
-        }
-    };
-}
-exports.ReadStruct = ReadStruct;
-function ReadWriteStruct(spec) {
-    return class ReadWriteStruct {
-        static get(s) {
-            return new this(s);
-        }
-        static put(s, v) {
-            write(s, spec, v);
-        }
-        constructor(s) {
-            Object.assign(this, read(s, spec));
-        }
-        write(s) {
-            write(s, spec, this);
-        }
-    };
-}
-exports.ReadWriteStruct = ReadWriteStruct;
-function isReader(type) {
-    return typeof type.get === 'function';
-}
-exports.isReader = isReader;
-function isWriter(type) {
-    return typeof type.put === 'function';
-}
-exports.isWriter = isWriter;
-function isType(type) {
-    return isReader(type) && isWriter(type);
-}
-exports.isType = isType;
-function read(s, spec, obj) {
-    return isReader(spec)
-        ? spec.get(s, obj)
-        : Object.entries(spec).reduce((obj, [k, t]) => (obj[k] = read(s, t, obj), obj), { obj });
-}
-exports.read = read;
-function read_more(s, specs, obj) {
-    return Object.entries(specs).reduce((obj, spec) => {
-        obj[spec[0]] = isReader(spec[1])
-            ? spec[1].get(s, obj)
-            : read_more(s, spec[1], obj[spec[0]]);
-        return obj;
-    }, obj);
-}
-exports.read_more = read_more;
-function write(s, type, value) {
-    if (isWriter(type))
-        type.put(s, value);
-    else
-        Object.entries(type).map(([k, t]) => write(s, t, value[k]));
-}
-exports.write = write;
-function readx(s, type, obj) {
-    return typeof type === 'function' ? type(obj)
-        : isReader(type) ? type.get(s, obj)
-            : type;
-}
-function writex(s, type, value) {
-    if (isWriter(type))
-        type.put(s, value);
-}
-//-----------------------------------------------------------------------------
-//	stream
-//-----------------------------------------------------------------------------
-class stream {
-    //	public buffer: ArrayBuffer;
-    buffer;
-    offset0;
-    offset;
-    end;
-    constructor(data) {
-        this.buffer = data.buffer;
-        this.offset = this.offset0 = data.byteOffset;
-        this.end = data.byteOffset + data.byteLength;
-    }
-    remaining() {
-        return this.end - this.offset;
-    }
-    remainder() {
-        return new Uint8Array(this.buffer, this.offset);
-    }
-    tell() {
-        return this.offset - this.offset0;
-    }
-    seek(offset) {
-        this.offset = this.offset0 + offset;
-        return this;
-    }
-    skip(offset) {
-        this.offset += offset;
-        return this;
-    }
-    align(align) {
-        const offset = this.tell() % align;
-        if (offset)
-            this.skip(align - offset);
-    }
-    dataview(len) {
-        if (this.offset + len > this.end)
-            throw new Error('stream: out of bounds');
-        const dv = new DataView(this.buffer, this.offset);
-        this.offset += len;
-        return dv;
-    }
-    buffer_at(offset, len) {
-        return new Uint8Array(this.buffer, this.offset0 + offset, len ?? this.end - (this.offset0 + offset));
-    }
-    read_buffer(len) {
-        const offset = this.offset;
-        this.offset = Math.min(this.end, offset + len);
-        const len2 = this.offset - offset;
-        return new Uint8Array(this.buffer, offset, this.offset - offset);
-        //		this.offset += len;
-        //		return new Uint8Array(this.buffer, offset, len);
-    }
-    write_buffer(v) {
-        const dv = this.dataview(v.length);
-        let offset = 0;
-        for (const i of v)
-            dv.setUint8(offset++, v[i]);
-    }
-}
-exports.stream = stream;
-class stream_grow extends stream {
-    constructor(data) {
-        super(data ?? new Uint8Array(1024));
-    }
-    checksize(len) {
-        if (this.offset + len > this.buffer.byteLength) {
-            const newBuffer = new ArrayBuffer(this.buffer.byteLength * 2);
-            new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
-            this.buffer = newBuffer;
-            this.offset -= this.offset0;
-            this.offset0 = 0;
-        }
-    }
-    dataview(len) {
-        this.checksize(len);
-        return super.dataview(len);
-    }
-    buffer_at(offset, len) {
-        this.checksize(offset + len - this.offset);
-        return super.buffer_at(offset, len);
-    }
-    read_buffer(len) {
-        this.checksize(len);
-        return super.read_buffer(len);
-    }
-    write_buffer(v) {
-        this.checksize(v.length);
-        super.write_buffer(v);
-    }
-    terminate() {
-        return new Uint8Array(this.buffer, this.offset0, this.offset - this.offset0);
-    }
-}
-exports.stream_grow = stream_grow;
-class dummy_dataview {
-    offset;
-    buffer;
-    byteLength;
-    byteOffset;
-    [Symbol.toStringTag];
-    constructor(offset) {
-        this.offset = offset;
-    }
-    getFloat32(byteOffset, littleEndian) { return this.offset; }
-    getFloat64(byteOffset, littleEndian) { return this.offset; }
-    getInt8(byteOffset) { return this.offset; }
-    getInt16(byteOffset, littleEndian) { return this.offset; }
-    getInt32(byteOffset, littleEndian) { return this.offset; }
-    getUint8(byteOffset) { return this.offset; }
-    getUint16(byteOffset, littleEndian) { return this.offset; }
-    getUint32(byteOffset, littleEndian) { return this.offset; }
-    getBigInt64(byteOffset, littleEndian) { return BigInt(this.offset); }
-    getBigUint64(byteOffset, littleEndian) { return BigInt(this.offset); }
-    setFloat32(byteOffset, value, littleEndian) { }
-    setFloat64(byteOffset, value, littleEndian) { }
-    setInt8(byteOffset, value) { }
-    setInt16(byteOffset, value, littleEndian) { }
-    setInt32(byteOffset, value, littleEndian) { }
-    setUint8(byteOffset, value) { }
-    setUint16(byteOffset, value, littleEndian) { }
-    setUint32(byteOffset, value, littleEndian) { }
-    setBigInt64(byteOffset, value, littleEndian) { }
-    setBigUint64(byteOffset, value, littleEndian) { }
-}
-class dummy {
-    offset = 0;
-    remaining() { return 0; }
-    remainder() { return this.offset; }
-    tell() { return this.offset; }
-    seek(offset) { this.offset = offset; }
-    skip(offset) { this.offset += offset; }
-    align(align) { const offset = this.tell() % align; if (offset)
-        this.skip(align - offset); }
-    dataview(len) {
-        const dv = new dummy_dataview(this.offset);
-        this.offset += len;
-        return dv;
-    }
-    read_buffer(len) {
-        const offset = this.offset;
-        this.offset += len;
-        return offset;
-    }
-    write_buffer(v) { }
-}
-exports.dummy = dummy;
-//-----------------------------------------------------------------------------
-//	numeric types
-//-----------------------------------------------------------------------------
-function endian_from_stream(type) {
-    return {
-        get(s) { return type(s.be).get(s); },
-        put(s, v) { type(s.be).put(s, v); }
-    };
-}
-function endian(type, be) {
-    return be === undefined ? endian_from_stream(type) : type(be);
-}
-//8 bit
-exports.UINT8 = {
-    get(s) { return s.dataview(1).getUint8(0); },
-    put(s, v) { s.dataview(1).setUint8(0, v); }
-};
-exports.INT8 = {
-    get(s) { return s.dataview(1).getInt8(0); },
-    put(s, v) { s.dataview(1).setInt8(0, v); }
-};
-//16 bit
-function _UINT16(be) {
-    return {
-        get(s) { return s.dataview(2).getUint16(0, !be); },
-        put(s, v) { s.dataview(2).setUint16(0, v, !be); }
-    };
-}
-function _INT16(be) {
-    return {
-        get(s) { return s.dataview(2).getInt16(0, !be); },
-        put(s, v) { s.dataview(2).setInt16(0, v, !be); }
-    };
-}
-exports.UINT16_LE = _UINT16(false);
-exports.UINT16_BE = _UINT16(true);
-exports.INT16_LE = _INT16(false);
-exports.INT16_BE = _INT16(true);
-exports.UINT16 = endian_from_stream(_UINT16);
-exports.INT16 = endian_from_stream(_INT16);
-//32 bit
-function _UINT32(be) {
-    return {
-        get(s) { return s.dataview(4).getUint32(0, !be); },
-        put(s, v) { s.dataview(4).setUint32(0, v, !be); }
-    };
-}
-function _INT32(be) {
-    return {
-        get(s) { return s.dataview(4).getInt32(0, !be); },
-        put(s, v) { s.dataview(4).setInt32(0, v, !be); }
-    };
-}
-exports.UINT32_LE = _UINT32(false);
-exports.UINT32_BE = _UINT32(true);
-exports.INT32_LE = _INT32(false);
-exports.INT32_BE = _INT32(true);
-exports.UINT32 = endian_from_stream(_UINT32);
-exports.INT32 = endian_from_stream(_INT32);
-//64 bit 
-function _UINT64(be) {
-    return {
-        get(s) { return utils.getBigUint(s.dataview(8), 8, !be); },
-        put(s, v) { utils.putBigUint(s.dataview(8), v, 8, !be); }
-    };
-}
-function _INT64(be) {
-    return {
-        get(s) { return utils.getBigInt(s.dataview(8), 8, !be); },
-        put(s, v) { utils.putBigUint(s.dataview(8), v, 8, !be); }
-    };
-}
-exports.UINT64_LE = _UINT64(false);
-exports.UINT64_BE = _UINT64(true);
-exports.UINT64 = endian_from_stream(_UINT64);
-exports.INT64_LE = _INT64(false);
-exports.INT64_BE = _INT64(true);
-exports.INT64 = endian_from_stream(_INT64);
-//computed int
-function UINT(bits, be) {
-    if (bits & 7)
-        throw new Error('bits must be multiple of 8');
-    return bits === 8 ? exports.UINT8
-        : bits > 56
-            ? endian((be) => ({
-                get(s) { return utils.getBigUint(s.dataview(bits / 8), bits / 8, !be); },
-                put(s, v) { utils.putBigUint(s.dataview(bits / 8), v, bits / 8, !be); }
-            }), be)
-            : endian(bits == 16 ? _UINT16 : bits == 32 ? _UINT32 :
-                (be) => ({
-                    get(s) { return utils.getUint(s.dataview(bits / 8), bits / 8, !be); },
-                    put(s, v) { utils.putUint(s.dataview(bits / 8), v, bits / 8, !be); }
-                }), be);
-}
-exports.UINT = UINT;
-function INT(bits, be) {
-    if (bits & 7)
-        throw new Error('bits must be multiple of 8');
-    return bits === 8 ? exports.UINT8
-        : bits > 56
-            ? endian((be) => ({
-                get(s) { return utils.getBigInt(s.dataview(bits / 8), bits / 8, !be); },
-                put(s, v) { utils.putBigUint(s.dataview(bits / 8), v, bits / 8, !be); }
-            }), be)
-            : endian(bits == 16 ? _INT16 : bits == 32 ? _INT32 :
-                (be) => ({
-                    get(s) { return utils.getInt(s.dataview(bits / 8), bits / 8, !be); },
-                    put(s, v) { utils.putUint(s.dataview(bits / 8), v, bits / 8, !be); }
-                }), be);
-}
-exports.INT = INT;
-//float
-function _Float32(be) {
-    return {
-        get(s) { return s.dataview(4).getFloat32(0, !be); },
-        put(s, v) { s.dataview(4).setFloat32(0, v, !be); }
-    };
-}
-function _Float64(be) {
-    return {
-        get(s) { return s.dataview(8).getFloat64(0, !be); },
-        put(s, v) { s.dataview(8).setFloat64(0, v, !be); }
-    };
-}
-exports.Float32_LE = _Float32(false);
-exports.Float32_BE = _Float32(true);
-exports.Float64_LE = _Float64(false);
-exports.Float64_BE = _Float64(true);
-exports.Float32 = endian_from_stream(_Float32);
-exports.Float64 = endian_from_stream(_Float64);
-//leb128
-exports.ULEB128 = {
-    get(s) {
-        const buffer = s.remainder();
-        let t = 0;
-        let i = 0;
-        let b;
-        while ((b = buffer[i]) & 0x80 && i < 6)
-            t |= (b & 0x7f) << (i++ * 7);
-        if (!(b & 0x80)) {
-            s.skip(i);
-            return t;
-        }
-        let tn = BigInt(t);
-        while ((b = buffer[i]) & 0x80)
-            tn |= BigInt(b & 0x7f) << BigInt(i++ * 7);
-        tn |= BigInt(b) << BigInt(i++ * 7);
-        s.skip(i);
-        return tn;
-    },
-    put(s, v) {
-        const n = utils.highestSetIndex(v) / 7 + 1;
-        const buffer = new Uint8Array(n);
-        let i = 0;
-        if (typeof v === 'number') {
-            while (v > 127) {
-                buffer[i++] = (v & 0x7f) | 0x80;
-                v >>= 7;
-            }
-        }
-        else {
-            while (v > 127) {
-                buffer[i++] = Number(v & 0x7fn) | 0x80;
-                v >>= 7n;
-            }
-        }
-        buffer[i++] = Number(v);
-        s.write_buffer(buffer);
-    }
-};
-//-----------------------------------------------------------------------------
-//	string types
-//-----------------------------------------------------------------------------
-function StringType(len, encoding = 'utf8', zeroTerminated = false, lenScale) {
-    const lenScale2 = lenScale ?? (encoding == 'utf8' ? 1 : 2);
-    return {
-        get(s, obj) {
-            const len2 = readx(s, len, obj);
-            const v = utils.decodeText(s.read_buffer(len2 * lenScale2), encoding);
-            return zeroTerminated ? v.slice(0, -1) : v;
-        },
-        put(s, v) {
-            if (zeroTerminated)
-                v += '\0';
-            writex(s, len, v.length * 2 / lenScale2);
-            utils.encodeTextInto(v, s.read_buffer(v.length * lenScale2), encoding);
-        }
-    };
-}
-exports.StringType = StringType;
-exports.NullTerminatedStringType = {
-    get(s) {
-        const buf = [];
-        let b;
-        while ((b = s.dataview(1).getUint8(0)) != 0)
-            buf.push(b);
-        return String.fromCharCode(...buf);
-    },
-    put(s, v) {
-        return utils.encodeTextInto(v + '\0', s.read_buffer(v.length + 1), 'utf8');
-    }
-};
-function RemainingStringType(encoding = 'utf8', zeroTerminated = false) {
-    return {
-        get(s) { return utils.decodeText(s.remainder(), encoding); },
-        put(s, v) {
-            if (zeroTerminated)
-                v += '\0';
-            utils.encodeTextInto(v, s.remainder(), encoding);
-        }
-    };
-}
-exports.RemainingStringType = RemainingStringType;
-//-----------------------------------------------------------------------------
-//	array types
-//-----------------------------------------------------------------------------
-function readn(s, type, n, obj) {
-    const result = [];
-    //try {
-    for (let i = 0; i < n; i++)
-        result.push(read(s, type, obj));
-    //} catch (e) {
-    //	console.log(`binary.readn wanted ${n} items, but failed after ${result.length}`)
-    //}
-    return result;
-}
-exports.readn = readn;
-function writen(s, type, v) {
-    for (const i of v)
-        write(s, type, i);
-}
-exports.writen = writen;
-function ArrayType(len, elemtype) {
-    return {
-        get: (s, obj) => readn(s, elemtype, readx(s, len, obj), obj),
-        put: (s, v) => { writex(s, len, v.length); writen(s, elemtype, v); }
-    };
-}
-exports.ArrayType = ArrayType;
-function RemainingArrayType(elemtype) {
-    return {
-        get: (s, obj) => {
-            const result = [];
-            try {
-                let value;
-                while (s.remaining() && (value = read(s, elemtype, obj)) !== undefined)
-                    result.push(value);
-            }
-            catch (e) {
-                //meh
-            }
-            return result;
-        },
-        put: (s, v) => writen(s, elemtype, v)
-    };
-}
-exports.RemainingArrayType = RemainingArrayType;
-function withNames(array, func) {
-    return array.map((v, i) => [func(v, i) ?? `#${i}`, v]);
-}
-exports.withNames = withNames;
-const field = (field) => (v, i) => v[field];
-exports.field = field;
-const names = (names) => (v, i) => names[i];
-exports.names = names;
-function arrayWithNames(type, func) {
-    return {
-        get: (s) => withNames(read(s, type), func),
-        put: (s, v) => write(s, type, v.map(([, v]) => v))
-    };
-}
-exports.arrayWithNames = arrayWithNames;
-function objectWithNames(type, func) {
-    return {
-        get: (s) => Object.fromEntries(withNames(read(s, type), func)),
-        put: (s, v) => write(s, type, Object.values(v))
-    };
-}
-exports.objectWithNames = objectWithNames;
-function isConstructor(maker) {
-    return maker.prototype?.constructor.name;
-    //	return typeof maker === 'function' && maker.prototype && !!maker.prototype.constructor;
-}
-function make(maker, arg, opt) {
-    return isConstructor(maker) ? new maker(arg, opt) : maker(arg, opt);
-}
-function clone(obj) {
-    return Object.assign(Object.create(Object.getPrototypeOf(obj)), obj);
-}
-function Struct(spec) {
-    return {
-        get: (s, obj) => read(s, spec, obj),
-        put: (s, v) => { write(s, spec, v); }
-    };
-}
-exports.Struct = Struct;
-exports.Remainder = {
-    get: (s) => s.remainder(),
-    put: (s, v) => s.write_buffer(v)
-};
-function Buffer(len) {
-    return {
-        get: (s, obj) => s.read_buffer(readx(s, len, obj)),
-        put: (s, v) => { writex(s, len, v.length); s.write_buffer(v); }
-    };
-}
-exports.Buffer = Buffer;
-function SkipType(len) {
-    return {
-        get: (s) => s.skip(len),
-        put: (s, v) => s.skip(len)
-    };
-}
-exports.SkipType = SkipType;
-function AlignType(align) {
-    return {
-        get: (s) => s.align(align),
-        put: (s, v) => s.align(align)
-    };
-}
-exports.AlignType = AlignType;
-function Discard(type) {
-    return {
-        get(s) { read(s, type); return undefined; },
-    };
-}
-exports.Discard = Discard;
-function DontRead() {
-    return {
-        get(s) { return undefined; },
-        put(s, v) { }
-    };
-}
-exports.DontRead = DontRead;
-function SizeType(len, targettype) {
-    return {
-        get(s, obj) {
-            const size = readx(s, len, obj);
-            const s2 = clone(s);
-            s2.end = s2.offset + size;
-            return read(s2, targettype, obj);
-        },
-        put(s) { }
-    };
-}
-exports.SizeType = SizeType;
-function OffsetType(offsettype, targettype) {
-    return {
-        get(s, obj) {
-            const offset = readx(s, offsettype, obj);
-            const s2 = clone(s);
-            s2.offset = s2.offset0 += offset;
-            return read(s2, targettype, obj);
-        },
-        put(s) { }
-    };
-}
-exports.OffsetType = OffsetType;
-function MaybeOffsetType(offsettype, targettype) {
-    return {
-        get(s, obj) {
-            const offset = readx(s, offsettype, obj);
-            if (offset) {
-                const s2 = clone(s);
-                s2.offset = s2.offset0 += offset;
-                return read(s2, targettype, obj);
-            }
-        },
-        put(s) { }
-    };
-}
-exports.MaybeOffsetType = MaybeOffsetType;
-function as(type, maker) {
-    return {
-        get(s, obj) { return make(maker, read(s, type), obj); },
-        put(s, v) { write(s, type, v); }
-    };
-}
-exports.as = as;
-function Const(t) {
-    return {
-        get(s, obj) { return t; },
-        put(s, v) { }
-    };
-}
-exports.Const = Const;
-function Func(func) {
-    return {
-        get(s, obj) { return func(obj); },
-        put(s, v) { }
-    };
-}
-exports.Func = Func;
-function FuncType(func) {
-    return {
-        get(s, obj) { return read(s, func(obj), obj); },
-        put(s, v) { }
-    };
-}
-exports.FuncType = FuncType;
-function If(test, true_type, false_type) {
-    return {
-        get(s, obj) {
-            const x = readx(s, test, obj);
-            if (false_type)
-                read_more(s, x ? true_type : false_type, obj);
-            else if (x)
-                read_more(s, true_type, obj);
-            return {};
-        },
-        put(s, v) { }
-    };
-}
-exports.If = If;
-function Optional(test, type) {
-    return {
-        get(s, obj) { return readx(s, test, obj) ? read(s, type) : undefined; },
-        put(s, v) { }
-    };
-}
-exports.Optional = Optional;
-function Switch(test, switches) {
-    return {
-        get(s, obj) { const t = switches[readx(s, test, obj)]; return (t && read(s, t, obj)); },
-        put(s, v) { } // writex(s, test, )}// write(s, switches[test(obj)], v); }
-    };
-}
-exports.Switch = Switch;
-//-----------------------------------------------------------------------------
-//	TYPED  types
-//-----------------------------------------------------------------------------
-class hex {
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-    valueOf() { return this.value; }
-    toString() { return '0x' + this.value.toString(16); }
-}
-exports.hex = hex;
-exports.XINT16 = as(exports.UINT16, hex);
-exports.XINT32 = as(exports.UINT32, hex);
-exports.XINT64 = as(exports.UINT64, hex);
-exports.XINT16_LE = as(exports.UINT16_LE, hex);
-exports.XINT32_LE = as(exports.UINT32_LE, hex);
-exports.XINT64_LE = as(exports.UINT64_LE, hex);
-function EnumV(e) {
-    return (x) => x;
-}
-exports.EnumV = EnumV;
-function Enum(e) {
-    const e1 = Object.entries(e).filter(([k, v]) => typeof v === 'number').sort(([, v1], [, v2]) => v2 - v1);
-    const e2 = Object.fromEntries(e1.map(([k, v]) => [v, k]));
-    function split_enum(x) {
-        const results = [];
-        for (const k of e1) {
-            if (k[1] === 0) {
-                if (x == 0)
-                    return k[0];
-                break;
-            }
-            const n = Math.floor(x / k[1]);
-            if (n) {
-                results.push(n > 1 ? `${k[0]}*${n}` : k[0]);
-                x %= k[1];
-                if (!x)
-                    break;
-            }
-        }
-        if (results.length == 0)
-            return x.toString();
-        if (x)
-            results.push(x.toString());
-        return results.join('+');
-    }
-    return (x) => e2[x] ?? split_enum(x);
-}
-exports.Enum = Enum;
-function Flags(e, noFalse) {
-    const e1 = Object.entries(e).filter(([k, v]) => typeof v === 'number');
-    return (x) => typeof x === 'bigint'
-        ? e1.reduce((obj, [k, v]) => {
-            const y = x & BigInt(v);
-            if (y || !noFalse)
-                obj[k] = !utils.isPow2(v) ? y / BigInt(utils.lowestSet(v)) : !!y;
-            return obj;
-        }, {})
-        : e1.reduce((obj, [k, v]) => {
-            const y = x & v;
-            if (y || !noFalse)
-                obj[k] = !utils.isPow2(v) ? y / utils.lowestSet(v) : !!y;
-            return obj;
-        }, {});
-}
-exports.Flags = Flags;
-function BitFields(bitfields) {
-    return (x) => {
-        if (typeof x === 'bigint') {
-            let y = x;
-            const obj = {};
-            for (const i in bitfields) {
-                const bf = bitfields[i];
-                const bits = typeof bf === 'number' ? bf : bf[0];
-                const v = y & ((1n << BigInt(bits)) - 1n);
-                y >>= BigInt(bits);
-                obj[i] = typeof bf === 'number' ? v : make(bf[1], Number(v));
-            }
-            return obj;
-        }
-        else {
-            const obj = {};
-            let y = x;
-            for (const i in bitfields) {
-                const bf = bitfields[i];
-                const bits = typeof bf === 'number' ? bf : bf[0];
-                const v = y & ((1 << bits) - 1);
-                y >>= bits;
-                obj[i] = typeof bf === 'number' ? v : make(bf[1], v);
-            }
-            return obj;
-        }
-    };
-}
-exports.BitFields = BitFields;
-//shortcuts
-function asEnum(type, e) {
-    return as(type, Enum(e));
-}
-exports.asEnum = asEnum;
-function asFlags(type, e, noFalse = true) {
-    return as(type, Flags(e, noFalse));
-}
-exports.asFlags = asFlags;
-function asInt(type, radix = 10) {
-    return as(type, x => parseInt(x.trim(), radix));
-}
-exports.asInt = asInt;
-function asFixed(type, fracbits) {
-    const scale = 1 / (1 << fracbits);
-    return as(type, x => x * scale);
-}
-exports.asFixed = asFixed;
-//-----------------------------------------------------------------------------
-//	stream_endian:
-//	endianness stored in stream
-//-----------------------------------------------------------------------------
-class stream_endian extends stream {
-    be;
-    constructor(data, be) {
-        super(data);
-        this.be = be;
-    }
-}
-exports.stream_endian = stream_endian;