@libmedia/avutil 0.2.0

package/dist/cjs/struct/avpacket.d.ts

@@ -0,0 +1,125 @@
+import { AVPacketSideDataType } from "../codec";
+import { AVBufferRef } from "./avbuffer";
+import { Rational } from "./rational";
+export declare const enum AVPacketType {
+    AUDIO = 0,
+    VIDEO = 1
+}
+export declare const enum AVPacketFlags {
+    /**
+     * The packet contains a keyframe
+     */
+    AV_PKT_FLAG_KEY = 1,
+    /**
+     * The packet content is corrupted
+     */
+    AV_PKT_FLAG_CORRUPT = 2,
+    /**
+     * Flag is used to discard packets which are required to maintain valid
+     * decoder state but are not required for output and should be dropped
+     * after decoding.
+     */
+    AV_PKT_FLAG_DISCARD = 4,
+    /**
+     * The packet comes from a trusted source.
+     *
+     * Otherwise-unsafe constructs such as arbitrary pointers to data
+     * outside the packet may be followed.
+     */
+    AV_PKT_FLAG_TRUSTED = 8,
+    /**
+     * Flag is used to indicate packets that contain frames that can
+     * be discarded by the decoder.  I.e. Non-reference frames.
+     */
+    AV_PKT_FLAG_DISPOSABLE = 16,
+    /**
+     * The stream is end
+     */
+    AV_PKT_FLAG_END = 32
+}
+@struct
+export declare class AVPacketSideData {
+    data: pointer<uint8>;
+    size: size;
+    type: AVPacketSideDataType;
+}
+@struct
+export declare class AVProducerReferenceTime {
+    wallclock: int64;
+    flags: int32;
+}
+@struct
+export default class AVPacket {
+    /**
+     * A reference to the reference-counted buffer where the packet data is
+     * stored.
+     * May be NULL, then the packet data is not reference-counted.
+     */
+    buf: pointer<AVBufferRef>;
+    /**
+     * Presentation timestamp in AVStream->time_base units; the time at which
+     * the decompressed packet will be presented to the user.
+     * Can be AV_NOPTS_VALUE if it is not stored in the file.
+     * pts MUST be larger or equal to dts as presentation cannot happen before
+     * decompression, unless one wants to view hex dumps. Some formats misuse
+     * the terms dts and pts/cts to mean something different. Such timestamps
+     * must be converted to true pts/dts before they are stored in AVPacket.
+     */
+    pts: int64;
+    /**
+     * Decompression timestamp in AVStream->time_base units; the time at which
+     * the packet is decompressed.
+     * Can be AV_NOPTS_VALUE if it is not stored in the file.
+     */
+    dts: int64;
+    data: pointer<uint8>;
+    size: int32;
+    streamIndex: int32;
+    /**
+     * A combination of @AVPacketFlags values
+     */
+    flags: int32;
+    /**
+     * Additional packet data that can be provided by the container.
+     * Packet can contain several types of side information.
+     */
+    sideData: pointer<AVPacketSideData>;
+    sideDataElems: int32;
+    /**
+     * Duration of this packet in AVStream->time_base units, 0 if unknown.
+     * Equals next_pts - this_pts in presentation order.
+     */
+    duration: int64;
+    pos: int64;
+    /**
+     * for some private data of the user
+     */
+    opaque: pointer<void>;
+    /**
+     * AVBufferRef for free use by the API user. FFmpeg will never check the
+     * contents of the buffer ref. FFmpeg calls av_buffer_unref() on it when
+     * the packet is unreferenced. av_packet_copy_props() calls create a new
+     * reference with av_buffer_ref() for the target packet's opaque_ref field.
+     *
+     * This is unrelated to the opaque field, although it serves a similar
+     * purpose.
+     */
+    opaqueRef: pointer<AVBufferRef>;
+    /**
+     * Time base of the packet's timestamps.
+     */
+    timeBase: Rational;
+    /**
+     * 码流格式
+     * 对于 h264/h265/h266 标记是 annexb 还是 avcc 格式
+     */
+    bitFormat: int32;
+}
+@struct
+export declare class AVPacketRef extends AVPacket {
+    refCount: atomic_int32;
+}
+export interface AVPacketPool {
+    alloc: () => pointer<AVPacketRef>;
+    release: (avpacket: pointer<AVPacketRef>) => void;
+}

package/dist/cjs/struct/avpacket.js

@@ -0,0 +1,286 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.AVPacketRef = exports.AVProducerReferenceTime = exports.AVPacketSideData = void 0;
+
+const cheap__identifier__0 = require("@libmedia/cheap/function/definedMetaProperty"), cheap__symbol__1 = require("@libmedia/cheap/symbol"), cheap__identifier__15 = require("./avbuffer"), cheap__identifier__17 = require("./rational"), constant_1 = require("../constant"), rational_1 = require("./rational");
+
+class AVPacketSideData {
+    data=0;
+    size=constant_1.NOPTS_VALUE;
+    type=-1;
+}
+
+var prototype, map;
+
+exports.AVPacketSideData = AVPacketSideData, prototype = AVPacketSideData.prototype, 
+(map = new Map).set("data", {
+    0: 2,
+    1: 1,
+    2: 1,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 0,
+    8: 0
+}), map.set("size", {
+    0: 15,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 4,
+    8: 0
+}), map.set("type", {
+    0: 15,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 8,
+    8: 0
+}), cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStruct, !0), 
+cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructMaxBaseTypeByteLength, 4), 
+cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructLength, 12), 
+cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructKeysMeta, map);
+
+class AVProducerReferenceTime {
+    wallclock;
+    flags;
+}
+
+exports.AVProducerReferenceTime = AVProducerReferenceTime, function(prototype) {
+    var map = new Map;
+    map.set("wallclock", {
+        0: 17,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 0,
+        8: 0
+    }), map.set("flags", {
+        0: 15,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 8,
+        8: 0
+    }), cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStruct, !0), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructMaxBaseTypeByteLength, 8), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructLength, 16), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructKeysMeta, map);
+}(AVProducerReferenceTime.prototype);
+
+class AVPacket {
+    buf=0;
+    pts=constant_1.NOPTS_VALUE_BIGINT;
+    dts=constant_1.NOPTS_VALUE_BIGINT;
+    data=0;
+    size=0;
+    streamIndex=constant_1.NOPTS_VALUE;
+    flags=0;
+    sideData=0;
+    sideDataElems=0;
+    duration=constant_1.NOPTS_VALUE_BIGINT;
+    pos=constant_1.NOPTS_VALUE_BIGINT;
+    opaque=0;
+    opaqueRef=0;
+    timeBase=new rational_1.Rational({
+        den: constant_1.AV_TIME_BASE,
+        num: 1
+    });
+    bitFormat=0;
+}
+
+exports.default = AVPacket, function(prototype) {
+    var map = new Map;
+    map.set("buf", {
+        0: cheap__identifier__15.AVBufferRef,
+        1: 1,
+        2: 1,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 0,
+        8: 0
+    }), map.set("pts", {
+        0: 17,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 8,
+        8: 0
+    }), map.set("dts", {
+        0: 17,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 16,
+        8: 0
+    }), map.set("data", {
+        0: 2,
+        1: 1,
+        2: 1,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 24,
+        8: 0
+    }), map.set("size", {
+        0: 15,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 28,
+        8: 0
+    }), map.set("streamIndex", {
+        0: 15,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 32,
+        8: 0
+    }), map.set("flags", {
+        0: 15,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 36,
+        8: 0
+    }), map.set("sideData", {
+        0: AVPacketSideData,
+        1: 1,
+        2: 1,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 40,
+        8: 0
+    }), map.set("sideDataElems", {
+        0: 15,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 44,
+        8: 0
+    }), map.set("duration", {
+        0: 17,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 48,
+        8: 0
+    }), map.set("pos", {
+        0: 17,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 56,
+        8: 0
+    }), map.set("opaque", {
+        0: 1,
+        1: 1,
+        2: 1,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 64,
+        8: 0
+    }), map.set("opaqueRef", {
+        0: cheap__identifier__15.AVBufferRef,
+        1: 1,
+        2: 1,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 68,
+        8: 0
+    }), map.set("timeBase", {
+        0: cheap__identifier__17.Rational,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 72,
+        8: 0
+    }), map.set("bitFormat", {
+        0: 15,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 80,
+        8: 0
+    }), cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStruct, !0), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructMaxBaseTypeByteLength, 8), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructLength, 88), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructKeysMeta, map);
+}(AVPacket.prototype);
+
+class AVPacketRef extends AVPacket {
+    refCount;
+}
+
+exports.AVPacketRef = AVPacketRef, function(prototype) {
+    var map = new Map;
+    map.set("refCount", {
+        0: 16,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 88,
+        8: 0
+    }), cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStruct, !0), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructMaxBaseTypeByteLength, 8), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructLength, 96), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructKeysMeta, map);
+}(AVPacketRef.prototype);
+//# sourceMappingURL=avpacket.js.map

package/dist/cjs/struct/avpacket.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["constant_1","require","rational_1","AVPacketSideData","data","size","NOPTS_VALUE","type","exports","AVProducerReferenceTime","wallclock","flags","AVPacket","buf","pts","NOPTS_VALUE_BIGINT","dts","streamIndex","sideData","sideDataElems","duration","pos","opaque","opaqueRef","timeBase","Rational","den","AV_TIME_BASE","num","bitFormat","default","AVPacketRef","refCount"],"sources":["../../../struct/avpacket.ts"],"mappings":";;;;;;0OA0BAA,aAAAC,QAAA,gBAEAC,aAAAD,QAAA;;AAyCA,MACaE;IACXC,KAAI;IAEJC,KAAaL,WAAAM;IAEbC,MAAI;;;;;AANNC,QAAAL,qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,MACaM;IACXC;IACAC;;;AAHFH,QAAAC,mD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,MACqBG;IAMnBC,IAAG;IAWHC,IAAad,WAAAe;IAObC,IAAahB,WAAAe;IAEbX,KAAI;IAEJC,KAAc;IAEdY,YAAqBjB,WAAAM;IAKrBK,MAAe;IAMfO,SAAQ;IACRC,cAAuB;IAMvBC,SAAkBpB,WAAAe;IAElBM,IAAarB,WAAAe;IAKbO,OAAM;IAWNC,UAAS;IAKTC,SAAqB,IAAItB,WAAAuB,SAAS;QAAEC,KAAK1B,WAAA2B;QAAcC,KAAK;;IAM5DC,UAAmB;;;AA9ErBrB,QAAAsB,UAAAlB,U;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiFA,MACamB,oBAAoBnB;IAC/BoB;;;AAFFxB,QAAAuB,2B","ignoreList":[]}

package/dist/cjs/struct/avpcmbuffer.d.ts

@@ -0,0 +1,44 @@
+@struct
+export default class AVPCMBuffer {
+    /**
+     * pcm 数据
+     * 可同时存放多个 channel 数据
+     */
+    data: pointer<pointer<uint8>>;
+    /**
+     * data 每一个 channel 的缓冲区大小
+     */
+    linesize: int32;
+    /**
+     * 当前存放了多少个采样点
+     */
+    nbSamples: int32;
+    /**
+     * 当前 data 每个 channel 能存放的最大采样点数
+     */
+    maxnbSamples: int32;
+    /**
+     * 声道数
+     */
+    channels: int32;
+    /**
+     * 采样率
+     */
+    sampleRate: int32;
+    /**
+     * pts
+     */
+    timestamp: int64;
+    /**
+     * 时长
+     */
+    duration: double;
+}
+@struct
+export declare class AVPCMBufferRef extends AVPCMBuffer {
+    refCount: atomic_int32;
+}
+export interface AVPCMBufferPool {
+    alloc: () => pointer<AVPCMBufferRef>;
+    release: (buffer: pointer<AVPCMBufferRef>) => void;
+}

package/dist/cjs/struct/avpcmbuffer.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.AVPCMBufferRef = void 0;
+
+const cheap__identifier__0 = require("@libmedia/cheap/function/definedMetaProperty"), cheap__symbol__1 = require("@libmedia/cheap/symbol");
+
+class AVPCMBuffer {
+    data;
+    linesize;
+    nbSamples;
+    maxnbSamples;
+    channels;
+    sampleRate;
+    timestamp;
+    duration;
+}
+
+var prototype, map;
+
+exports.default = AVPCMBuffer, prototype = AVPCMBuffer.prototype, (map = new Map).set("data", {
+    0: 2,
+    1: 1,
+    2: 2,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 0,
+    8: 0
+}), map.set("linesize", {
+    0: 15,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 4,
+    8: 0
+}), map.set("nbSamples", {
+    0: 15,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 8,
+    8: 0
+}), map.set("maxnbSamples", {
+    0: 15,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 12,
+    8: 0
+}), map.set("channels", {
+    0: 15,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 16,
+    8: 0
+}), map.set("sampleRate", {
+    0: 15,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 20,
+    8: 0
+}), map.set("timestamp", {
+    0: 17,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 24,
+    8: 0
+}), map.set("duration", {
+    0: 19,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 32,
+    8: 0
+}), cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStruct, !0), 
+cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructMaxBaseTypeByteLength, 8), 
+cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructLength, 40), 
+cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructKeysMeta, map);
+
+class AVPCMBufferRef extends AVPCMBuffer {
+    refCount;
+}
+
+exports.AVPCMBufferRef = AVPCMBufferRef, function(prototype) {
+    var map = new Map;
+    map.set("refCount", {
+        0: 16,
+        1: 0,
+        2: 0,
+        3: 0,
+        4: 0,
+        5: 0,
+        6: 0,
+        7: 40,
+        8: 0
+    }), cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStruct, !0), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructMaxBaseTypeByteLength, 8), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructLength, 48), 
+    cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructKeysMeta, map);
+}(AVPCMBufferRef.prototype);
+//# sourceMappingURL=avpcmbuffer.js.map

package/dist/cjs/struct/avpcmbuffer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AVPCMBuffer","data","linesize","nbSamples","maxnbSamples","channels","sampleRate","timestamp","duration","exports","default","AVPCMBufferRef","refCount"],"sources":["../../../struct/avpcmbuffer.ts"],"mappings":";;;;;;;;AAyBA,MACqBA;IAKnBC;IAIAC;IAIAC;IAIAC;IAIAC;IAIAC;IAIAC;IAIAC;;;;;AAlCFC,QAAAC,UAAAV,a;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MACaW,uBAAuBX;IAClCY;;;AAFFH,QAAAE,iC","ignoreList":[]}

package/dist/cjs/struct/avsubtitle.d.ts

@@ -0,0 +1,30 @@
+import { Rational } from "./rational";
+export declare const enum AVSubtitleType {
+    SUBTITLE_NONE = 0,
+    /**
+     * Plain text, the text field must be set by the decoder and is
+     * authoritative. ass and pict fields may contain approximations.
+     */
+    SUBTITLE_TEXT = 1,
+    /**
+     * Formatted webvtt, the ass field must be set by the decoder and is
+     * authoritative. pict and text fields may contain approximations.
+     */
+    SUBTITLE_WEBVTT = 2,
+    /**
+     * Formatted text, the ass field must be set by the decoder and is
+     * authoritative. pict and text fields may contain approximations.
+     */
+    SUBTITLE_ASS = 3
+}
+export interface AVSubtitleRect {
+    flags: int32;
+    type: AVSubtitleType;
+    text: string;
+}
+export interface AVSubtitle {
+    pts: int64;
+    duration: int64;
+    timeBase: Rational;
+    rects: AVSubtitleRect[];
+}

package/dist/cjs/struct/avsubtitle.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+//# sourceMappingURL=avsubtitle.js.map

package/dist/cjs/struct/avsubtitle.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":[],"mappings":"","ignoreList":[]}

package/dist/cjs/struct/rational.d.ts

@@ -0,0 +1,15 @@
+@struct
+export declare class Rational {
+    /**
+     * 分子
+     */
+    num: int32;
+    /**
+     * 分母
+     */
+    den: int32;
+    constructor(init?: {
+        den: number;
+        num: number;
+    });
+}

package/dist/cjs/struct/rational.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.Rational = void 0;
+
+const cheap__identifier__0 = require("@libmedia/cheap/function/definedMetaProperty"), cheap__symbol__1 = require("@libmedia/cheap/symbol");
+
+class Rational {
+    num=1;
+    den=1;
+    constructor(init) {
+        init && (this.den = init.den, this.num = init.num);
+    }
+}
+
+var prototype, map;
+
+exports.Rational = Rational, prototype = Rational.prototype, (map = new Map).set("num", {
+    0: 15,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 0,
+    8: 0
+}), map.set("den", {
+    0: 15,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0,
+    6: 0,
+    7: 4,
+    8: 0
+}), cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStruct, !0), 
+cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructMaxBaseTypeByteLength, 4), 
+cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructLength, 8), 
+cheap__identifier__0.default(prototype, cheap__symbol__1.symbolStructKeysMeta, map);
+//# sourceMappingURL=rational.js.map

package/dist/cjs/struct/rational.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Rational","num","den","constructor","init","this","exports"],"sources":["../../../struct/rational.ts"],"mappings":";;;;;;;;AAyBA,MACaA;IAIXC,IAAa;IAIbC,IAAa;IAEb,WAAAC,CAAYC;QACNA,SACFC,KAAKH,MAAME,KAAKF,KAChBG,KAAKJ,MAAMG,KAAKH;AAEpB;;;;;AAhBFK,QAAAN,qB","ignoreList":[]}

package/dist/cjs/util/amf.d.ts

@@ -0,0 +1,10 @@
+import BufferReader from "@libmedia/common/io/BufferReader";
+import IOReader from "@libmedia/common/io/IOReader";
+import BufferWriter from "@libmedia/common/io/BufferWriter";
+import IOWriterSync from "@libmedia/common/io/IOWriterSync";
+export declare function parseObject(ioReader: IOReader | BufferReader, endPos: bigint): Promise<{
+    key: string;
+    value: any;
+}>;
+export declare function parseValue(ioReader: IOReader | BufferReader, endPos: bigint): Promise<any>;
+export declare function writeValue(ioWriter: IOWriterSync | BufferWriter, value: any): void;