@naeemo/capnp 0.8.1 → 0.9.1

package/dist/message-reader-_TCBf61G.js

@@ -0,0 +1,712 @@
+#!/usr/bin/env node
+import { a as decodePointer, i as PointerTag, n as WORD_SIZE, o as encodeListPointer, r as ElementSize, s as encodeStructPointer, t as Segment } from "./segment-yid_PYS5.js";
+
+//#region src/core/message-builder.ts
+/**
+* Cap'n Proto MessageBuilder
+* 纯 TypeScript 实现
+*/
+var MessageBuilder = class {
+	segment;
+	rootSet = false;
+	constructor() {
+		this.segment = new Segment(1024);
+		this.segment.allocate(1);
+	}
+	/**
+	* 初始化根结构
+	*/
+	initRoot(dataWords, pointerCount) {
+		if (this.rootSet) throw new Error("Root already initialized");
+		const size = dataWords + pointerCount;
+		const structOffset = this.segment.allocate(size);
+		const rootPtr = encodeStructPointer(structOffset - 1, dataWords, pointerCount);
+		this.segment.setWord(0, rootPtr);
+		this.rootSet = true;
+		return new StructBuilder(this, 0, structOffset, dataWords, pointerCount);
+	}
+	/**
+	* 序列化为 ArrayBuffer
+	*/
+	toArrayBuffer() {
+		const segmentData = this.segment.asUint8Array();
+		const wordCount = this.segment.wordCount;
+		const header = /* @__PURE__ */ new ArrayBuffer(8);
+		const headerView = new DataView(header);
+		headerView.setUint32(0, 0, true);
+		headerView.setUint32(4, wordCount, true);
+		const result = new Uint8Array(8 + segmentData.byteLength);
+		result.set(new Uint8Array(header), 0);
+		result.set(segmentData, 8);
+		return result.buffer;
+	}
+	/**
+	* 获取段（内部使用）
+	*/
+	getSegment() {
+		return this.segment;
+	}
+};
+/**
+* 结构构建器
+*/
+var StructBuilder = class StructBuilder {
+	constructor(message, segmentIndex, wordOffset, dataWords, pointerCount) {
+		this.message = message;
+		this.segmentIndex = segmentIndex;
+		this.wordOffset = wordOffset;
+		this.dataWords = dataWords;
+		this.pointerCount = pointerCount;
+	}
+	/**
+	* 设置 bool 字段
+	*/
+	setBool(bitOffset, value) {
+		const byteOffset = Math.floor(bitOffset / 8);
+		const bitInByte = bitOffset % 8;
+		const view = this.message.getSegment().dataView;
+		const offset = this.wordOffset * WORD_SIZE + byteOffset;
+		const current = view.getUint8(offset);
+		const newValue = value ? current | 1 << bitInByte : current & ~(1 << bitInByte);
+		view.setUint8(offset, newValue);
+	}
+	/**
+	* 设置 int8 字段
+	*/
+	setInt8(byteOffset, value) {
+		this.message.getSegment().dataView.setInt8(this.wordOffset * WORD_SIZE + byteOffset, value);
+	}
+	/**
+	* 设置 int16 字段
+	*/
+	setInt16(byteOffset, value) {
+		this.message.getSegment().dataView.setInt16(this.wordOffset * WORD_SIZE + byteOffset, value, true);
+	}
+	/**
+	* 设置 int32 字段
+	*/
+	setInt32(byteOffset, value) {
+		this.message.getSegment().dataView.setInt32(this.wordOffset * WORD_SIZE + byteOffset, value, true);
+	}
+	/**
+	* 设置 int64 字段
+	*/
+	setInt64(byteOffset, value) {
+		const segment = this.message.getSegment();
+		const offset = this.wordOffset * WORD_SIZE + byteOffset;
+		segment.dataView.setUint32(offset, Number(value & BigInt(4294967295)), true);
+		segment.dataView.setInt32(offset + 4, Number(value >> BigInt(32)), true);
+	}
+	/**
+	* 设置 uint8 字段
+	*/
+	setUint8(byteOffset, value) {
+		this.message.getSegment().dataView.setUint8(this.wordOffset * WORD_SIZE + byteOffset, value);
+	}
+	/**
+	* 设置 uint16 字段
+	*/
+	setUint16(byteOffset, value) {
+		this.message.getSegment().dataView.setUint16(this.wordOffset * WORD_SIZE + byteOffset, value, true);
+	}
+	/**
+	* 设置 uint32 字段
+	*/
+	setUint32(byteOffset, value) {
+		this.message.getSegment().dataView.setUint32(this.wordOffset * WORD_SIZE + byteOffset, value, true);
+	}
+	/**
+	* 设置 uint64 字段
+	*/
+	setUint64(byteOffset, value) {
+		const segment = this.message.getSegment();
+		const offset = this.wordOffset * WORD_SIZE + byteOffset;
+		segment.dataView.setUint32(offset, Number(value & BigInt(4294967295)), true);
+		segment.dataView.setUint32(offset + 4, Number(value >> BigInt(32)), true);
+	}
+	/**
+	* 设置 float32 字段
+	*/
+	setFloat32(byteOffset, value) {
+		this.message.getSegment().dataView.setFloat32(this.wordOffset * WORD_SIZE + byteOffset, value, true);
+	}
+	/**
+	* 设置 float64 字段
+	*/
+	setFloat64(byteOffset, value) {
+		this.message.getSegment().dataView.setFloat64(this.wordOffset * WORD_SIZE + byteOffset, value, true);
+	}
+	/**
+	* 获取 uint16 字段（用于 UnionBuilder 读取 tag）
+	*/
+	getUint16(byteOffset) {
+		return this.message.getSegment().dataView.getUint16(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 设置文本字段
+	*/
+	setText(pointerIndex, value) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const segment = this.message.getSegment();
+		const bytes = new TextEncoder().encode(`${value}\0`);
+		const wordCount = Math.ceil(bytes.length / WORD_SIZE);
+		const listOffset = segment.allocate(wordCount);
+		new Uint8Array(segment.dataView.buffer, listOffset * WORD_SIZE, bytes.length).set(bytes);
+		const ptr = encodeListPointer(listOffset - ptrOffset - 1, ElementSize.BYTE, bytes.length);
+		segment.setWord(ptrOffset, ptr);
+	}
+	/**
+	* 设置数据字段（Uint8Array）
+	* @param pointerIndex - 指针索引
+	* @param value - Uint8Array 数据
+	*/
+	setData(pointerIndex, value) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const segment = this.message.getSegment();
+		if (value.length === 0) {
+			const ptr = encodeListPointer(0, ElementSize.BYTE, 0);
+			segment.setWord(ptrOffset, ptr);
+			return;
+		}
+		const wordCount = Math.ceil(value.length / WORD_SIZE);
+		const listOffset = segment.allocate(wordCount);
+		new Uint8Array(segment.dataView.buffer, listOffset * WORD_SIZE, value.length).set(value);
+		const ptr = encodeListPointer(listOffset - ptrOffset - 1, ElementSize.BYTE, value.length);
+		segment.setWord(ptrOffset, ptr);
+	}
+	/**
+	* 初始化嵌套结构
+	*/
+	initStruct(pointerIndex, dataWords, pointerCount) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const segment = this.message.getSegment();
+		const size = dataWords + pointerCount;
+		const structOffset = segment.allocate(size);
+		const ptr = encodeStructPointer(structOffset - ptrOffset - 1, dataWords, pointerCount);
+		segment.setWord(ptrOffset, ptr);
+		return new StructBuilder(this.message, 0, structOffset, dataWords, pointerCount);
+	}
+	/**
+	* 初始化列表
+	*/
+	initList(pointerIndex, elementSize, elementCount, structSize) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const segment = this.message.getSegment();
+		let elementWords = 1;
+		if (elementSize === ElementSize.BYTE) elementWords = 1;
+		else if (elementSize === ElementSize.TWO_BYTES) elementWords = 1;
+		else if (elementSize === ElementSize.FOUR_BYTES) elementWords = 1;
+		else if (elementSize === ElementSize.EIGHT_BYTES) elementWords = 1;
+		else if (elementSize === ElementSize.COMPOSITE && structSize) elementWords = structSize.dataWords + structSize.pointerCount;
+		const totalWords = elementWords * elementCount;
+		const listOffset = segment.allocate(totalWords);
+		const ptr = encodeListPointer(listOffset - ptrOffset - 1, elementSize, elementCount);
+		segment.setWord(ptrOffset, ptr);
+		return new ListBuilder(this.message, elementSize, elementCount, structSize, listOffset);
+	}
+};
+
+//#endregion
+//#region src/core/list.ts
+/**
+* Cap'n Proto List 实现
+* 纯 TypeScript
+*/
+/**
+* ListReader - 读取列表
+*/
+var ListReader = class {
+	segment;
+	startOffset;
+	segmentIndex;
+	constructor(message, segmentIndex, elementSize, elementCount, structSize, wordOffset) {
+		this.message = message;
+		this.elementSize = elementSize;
+		this.elementCount = elementCount;
+		this.structSize = structSize;
+		this.segmentIndex = segmentIndex;
+		this.segment = message.getSegment(segmentIndex);
+		this.startOffset = wordOffset;
+	}
+	/**
+	* 列表长度
+	*/
+	get length() {
+		return this.elementCount;
+	}
+	/**
+	* 获取元素（基础类型）
+	*/
+	getPrimitive(index) {
+		if (index < 0 || index >= this.elementCount) throw new RangeError("Index out of bounds");
+		switch (this.elementSize) {
+			case ElementSize.BIT: {
+				const byteOffset = Math.floor(index / 8);
+				const bitInByte = index % 8;
+				return (this.segment.dataView.getUint8(this.startOffset * WORD_SIZE + byteOffset) & 1 << bitInByte) !== 0 ? 1 : 0;
+			}
+			case ElementSize.BYTE: return this.segment.dataView.getUint8(this.startOffset * WORD_SIZE + index);
+			case ElementSize.TWO_BYTES: return this.segment.dataView.getUint16(this.startOffset * WORD_SIZE + index * 2, true);
+			case ElementSize.FOUR_BYTES: return this.segment.dataView.getUint32(this.startOffset * WORD_SIZE + index * 4, true);
+			case ElementSize.EIGHT_BYTES: {
+				const offset = this.startOffset * WORD_SIZE + index * 8;
+				const low = BigInt(this.segment.dataView.getUint32(offset, true));
+				return BigInt(this.segment.dataView.getUint32(offset + 4, true)) << BigInt(32) | low;
+			}
+			default: throw new Error(`Unsupported element size: ${this.elementSize}`);
+		}
+	}
+	/**
+	* 获取结构元素
+	*/
+	getStruct(index) {
+		if (!this.structSize) throw new Error("Not a struct list");
+		const { dataWords, pointerCount } = this.structSize;
+		const size = dataWords + pointerCount;
+		const offset = this.startOffset + index * size;
+		return new StructReader(this.message, this.segmentIndex, offset, dataWords, pointerCount);
+	}
+	/**
+	* 迭代器
+	*/
+	*[Symbol.iterator]() {
+		for (let i = 0; i < this.elementCount; i++) yield this.getPrimitive(i);
+	}
+};
+/**
+* ListBuilder - 构建列表
+*/
+var ListBuilder = class {
+	segment;
+	startOffset;
+	constructor(message, elementSize, elementCount, structSize, wordOffset) {
+		this.message = message;
+		this.elementSize = elementSize;
+		this.elementCount = elementCount;
+		this.structSize = structSize;
+		this.segment = message.getSegment();
+		this.startOffset = wordOffset;
+	}
+	/**
+	* 列表长度
+	*/
+	get length() {
+		return this.elementCount;
+	}
+	/**
+	* 设置基础类型元素
+	*/
+	setPrimitive(index, value) {
+		if (index < 0 || index >= this.elementCount) throw new RangeError("Index out of bounds");
+		switch (this.elementSize) {
+			case ElementSize.BIT: {
+				const byteOffset = Math.floor(index / 8);
+				const bitInByte = index % 8;
+				const offset = this.startOffset * WORD_SIZE + byteOffset;
+				const current = this.segment.dataView.getUint8(offset);
+				const newValue = value ? current | 1 << bitInByte : current & ~(1 << bitInByte);
+				this.segment.dataView.setUint8(offset, newValue);
+				break;
+			}
+			case ElementSize.BYTE:
+				this.segment.dataView.setUint8(this.startOffset * WORD_SIZE + index, Number(value));
+				break;
+			case ElementSize.TWO_BYTES:
+				this.segment.dataView.setUint16(this.startOffset * WORD_SIZE + index * 2, Number(value), true);
+				break;
+			case ElementSize.FOUR_BYTES:
+				this.segment.dataView.setUint32(this.startOffset * WORD_SIZE + index * 4, Number(value), true);
+				break;
+			case ElementSize.EIGHT_BYTES: {
+				const offset = this.startOffset * WORD_SIZE + index * 8;
+				const bigValue = value;
+				this.segment.dataView.setUint32(offset, Number(bigValue & BigInt(4294967295)), true);
+				this.segment.dataView.setUint32(offset + 4, Number(bigValue >> BigInt(32)), true);
+				break;
+			}
+			default: throw new Error(`Unsupported element size: ${this.elementSize}`);
+		}
+	}
+	/**
+	* 获取结构元素（用于修改）
+	*/
+	getStruct(index) {
+		if (!this.structSize) throw new Error("Not a struct list");
+		const { dataWords, pointerCount } = this.structSize;
+		const size = dataWords + pointerCount;
+		const offset = this.startOffset + index * size;
+		return new StructBuilder(this.message, 0, offset, dataWords, pointerCount);
+	}
+};
+
+//#endregion
+//#region src/core/message-reader.ts
+/**
+* Cap'n Proto MessageReader
+* 纯 TypeScript 实现
+*/
+/** 默认安全选项 */
+const DEFAULT_SECURITY_OPTIONS = {
+	maxSegments: 64,
+	maxTotalSize: 64 * 1024 * 1024,
+	strictMode: false
+};
+var MessageReader = class {
+	segments;
+	securityOptions;
+	constructor(buffer, securityOptions) {
+		this.securityOptions = {
+			...DEFAULT_SECURITY_OPTIONS,
+			...securityOptions
+		};
+		const uint8Array = buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer;
+		this.segments = [];
+		if (this.securityOptions.strictMode && uint8Array.byteLength > this.securityOptions.maxTotalSize) throw new Error(`Message size (${uint8Array.byteLength} bytes) exceeds maximum allowed size (${this.securityOptions.maxTotalSize} bytes)`);
+		if (uint8Array.byteLength < 8) return;
+		const view = new DataView(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength);
+		const firstWordLow = view.getUint32(0, true);
+		const firstWordHigh = view.getUint32(4, true);
+		const segmentCount = (firstWordLow & 4294967295) + 1;
+		const firstSegmentSize = firstWordHigh;
+		if (segmentCount > this.securityOptions.maxSegments) {
+			if (this.securityOptions.strictMode) throw new Error(`Segment count (${segmentCount}) exceeds maximum allowed (${this.securityOptions.maxSegments})`);
+			return;
+		}
+		let offset = 8;
+		const segmentSizes = [firstSegmentSize];
+		for (let i = 1; i < segmentCount; i++) {
+			if (offset + 4 > uint8Array.byteLength) {
+				if (this.securityOptions.strictMode) throw new Error(`Message ended prematurely while reading segment ${i} size (offset: ${offset}, length: ${uint8Array.byteLength})`);
+				this.segments = [];
+				return;
+			}
+			segmentSizes.push(view.getUint32(offset, true));
+			offset += 4;
+		}
+		offset = offset + 7 & -8;
+		if (offset > uint8Array.byteLength) {
+			if (this.securityOptions.strictMode) throw new Error(`Insufficient data for segment table (offset: ${offset}, length: ${uint8Array.byteLength})`);
+			this.segments = [];
+			return;
+		}
+		const headerSize = offset;
+		let totalBodySize = 0;
+		for (const size of segmentSizes) totalBodySize += size * WORD_SIZE;
+		const expectedTotalSize = headerSize + totalBodySize;
+		if (expectedTotalSize > this.securityOptions.maxTotalSize) {
+			if (this.securityOptions.strictMode) throw new Error(`Total message size (${expectedTotalSize} bytes) exceeds maximum allowed size (${this.securityOptions.maxTotalSize} bytes)`);
+			return;
+		}
+		this.segments = [];
+		for (const size of segmentSizes) {
+			if (offset + size * WORD_SIZE > uint8Array.byteLength) {
+				if (this.securityOptions.strictMode) throw new Error(`Insufficient data for segment (expected ${size * WORD_SIZE} bytes at offset ${offset}, but message is ${uint8Array.byteLength} bytes)`);
+				break;
+			}
+			const segmentBuffer = uint8Array.slice(offset, offset + size * WORD_SIZE);
+			this.segments.push(Segment.fromBuffer(segmentBuffer.buffer));
+			offset += size * WORD_SIZE;
+		}
+	}
+	/**
+	* 获取根结构
+	*/
+	getRoot(_dataWords, _pointerCount) {
+		const segment = this.segments[0];
+		const ptr = decodePointer(segment.getWord(0));
+		if (ptr.tag === PointerTag.STRUCT) {
+			const structPtr = ptr;
+			const dataOffset = 1 + structPtr.offset;
+			return new StructReader(this, 0, dataOffset, structPtr.dataWords, structPtr.pointerCount);
+		}
+		if (ptr.tag === PointerTag.FAR) {
+			const farPtr = ptr;
+			const targetSegment = this.getSegment(farPtr.targetSegment);
+			if (!targetSegment) throw new Error(`Far pointer references non-existent segment ${farPtr.targetSegment}`);
+			if (farPtr.doubleFar) {
+				const landingPadPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+				if (landingPadPtr.tag !== PointerTag.FAR) throw new Error("Double-far landing pad is not a far pointer");
+				const innerFarPtr = landingPadPtr;
+				const finalSegment = this.getSegment(innerFarPtr.targetSegment);
+				if (!finalSegment) throw new Error(`Double-far references non-existent segment ${innerFarPtr.targetSegment}`);
+				const structPtr = decodePointer(finalSegment.getWord(innerFarPtr.targetOffset));
+				const dataOffset = innerFarPtr.targetOffset + 1 + structPtr.offset;
+				return new StructReader(this, innerFarPtr.targetSegment, dataOffset, structPtr.dataWords, structPtr.pointerCount);
+			}
+			const structPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+			const dataOffset = farPtr.targetOffset + 1 + structPtr.offset;
+			return new StructReader(this, farPtr.targetSegment, dataOffset, structPtr.dataWords, structPtr.pointerCount);
+		}
+		throw new Error(`Root pointer is not a struct or far pointer: ${ptr.tag}`);
+	}
+	/**
+	* 获取段
+	*/
+	getSegment(index) {
+		return this.segments[index];
+	}
+	/**
+	* 解析指针，处理 far pointer 间接寻址
+	* 返回 { segmentIndex, wordOffset, pointer }，其中 pointer 是实际的 struct/list 指针
+	*/
+	resolvePointer(segmentIndex, wordOffset) {
+		const segment = this.getSegment(segmentIndex);
+		if (!segment) return null;
+		const ptrValue = segment.getWord(wordOffset);
+		if (ptrValue === 0n) return null;
+		const ptr = decodePointer(ptrValue);
+		if (ptr.tag === PointerTag.STRUCT || ptr.tag === PointerTag.LIST) return {
+			segmentIndex,
+			wordOffset: wordOffset + 1 + ptr.offset,
+			pointer: ptr
+		};
+		if (ptr.tag === PointerTag.FAR) {
+			const farPtr = ptr;
+			const targetSegment = this.getSegment(farPtr.targetSegment);
+			if (!targetSegment) return null;
+			if (farPtr.doubleFar) {
+				const landingPadPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+				if (landingPadPtr.tag !== PointerTag.FAR) return null;
+				const innerFarPtr = landingPadPtr;
+				const finalSegment = this.getSegment(innerFarPtr.targetSegment);
+				if (!finalSegment) return null;
+				const finalPtr = decodePointer(finalSegment.getWord(innerFarPtr.targetOffset));
+				if (finalPtr.tag !== PointerTag.STRUCT && finalPtr.tag !== PointerTag.LIST) return null;
+				const targetOffset = innerFarPtr.targetOffset + 1 + finalPtr.offset;
+				return {
+					segmentIndex: innerFarPtr.targetSegment,
+					wordOffset: targetOffset,
+					pointer: finalPtr
+				};
+			}
+			const landingPadPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+			if (landingPadPtr.tag !== PointerTag.STRUCT && landingPadPtr.tag !== PointerTag.LIST) return null;
+			const targetOffset = farPtr.targetOffset + 1 + landingPadPtr.offset;
+			return {
+				segmentIndex: farPtr.targetSegment,
+				wordOffset: targetOffset,
+				pointer: landingPadPtr
+			};
+		}
+		return null;
+	}
+	/**
+	* 段数量
+	*/
+	get segmentCount() {
+		return this.segments.length;
+	}
+	/**
+	* 获取当前安全选项配置
+	*/
+	getSecurityOptions() {
+		return { ...this.securityOptions };
+	}
+};
+/**
+* 结构读取器
+*/
+var StructReader = class StructReader {
+	constructor(message, segmentIndex, wordOffset, dataWords, pointerCount) {
+		this.message = message;
+		this.segmentIndex = segmentIndex;
+		this.wordOffset = wordOffset;
+		this.dataWords = dataWords;
+		this.pointerCount = pointerCount;
+	}
+	/**
+	* 获取 bool 字段
+	*/
+	getBool(bitOffset) {
+		const byteOffset = Math.floor(bitOffset / 8);
+		const bitInByte = bitOffset % 8;
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset >= dataSectionEnd) return false;
+		return (segment.dataView.getUint8(dataOffset) & 1 << bitInByte) !== 0;
+	}
+	/**
+	* 获取 int8 字段
+	*/
+	getInt8(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset >= dataSectionEnd) return 0;
+		return segment.dataView.getInt8(dataOffset);
+	}
+	/**
+	* 获取 int16 字段
+	*/
+	getInt16(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 2 > dataSectionEnd) return 0;
+		return segment.dataView.getInt16(dataOffset, true);
+	}
+	/**
+	* 获取 int32 字段
+	*/
+	getInt32(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 4 > dataSectionEnd) return 0;
+		return segment.dataView.getInt32(dataOffset, true);
+	}
+	/**
+	* 获取 int64 字段
+	*/
+	getInt64(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 8 > dataSectionEnd) return BigInt(0);
+		const low = BigInt(segment.dataView.getUint32(dataOffset, true));
+		return BigInt(segment.dataView.getInt32(dataOffset + 4, true)) << BigInt(32) | low;
+	}
+	/**
+	* 获取 uint8 字段
+	*/
+	getUint8(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset >= dataSectionEnd) return 0;
+		return segment.dataView.getUint8(dataOffset);
+	}
+	/**
+	* 获取 uint16 字段
+	*/
+	getUint16(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 2 > dataSectionEnd) return 0;
+		return segment.dataView.getUint16(dataOffset, true);
+	}
+	/**
+	* 获取 uint32 字段
+	*/
+	getUint32(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 4 > dataSectionEnd) return 0;
+		return segment.dataView.getUint32(dataOffset, true);
+	}
+	/**
+	* 获取 uint64 字段
+	*/
+	getUint64(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 8 > dataSectionEnd) return BigInt(0);
+		const low = BigInt(segment.dataView.getUint32(dataOffset, true));
+		return BigInt(segment.dataView.getUint32(dataOffset + 4, true)) << BigInt(32) | low;
+	}
+	/**
+	* 获取 float32 字段
+	*/
+	getFloat32(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 4 > dataSectionEnd) return 0;
+		return segment.dataView.getFloat32(dataOffset, true);
+	}
+	/**
+	* 获取 float64 字段
+	*/
+	getFloat64(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 8 > dataSectionEnd) return 0;
+		return segment.dataView.getFloat64(dataOffset, true);
+	}
+	/**
+	* 获取文本字段
+	*/
+	getText(pointerIndex) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const resolved = this.message.resolvePointer(this.segmentIndex, ptrOffset);
+		if (!resolved) return "";
+		const { segmentIndex, wordOffset, pointer } = resolved;
+		if (pointer.tag !== PointerTag.LIST) return "";
+		const listPtr = pointer;
+		const segment = this.message.getSegment(segmentIndex);
+		const byteLength = listPtr.elementCount > 0 ? listPtr.elementCount - 1 : 0;
+		if (byteLength === 0) return "";
+		const bytes = new Uint8Array(segment.dataView.buffer, wordOffset * WORD_SIZE, byteLength);
+		return new TextDecoder().decode(bytes);
+	}
+	/**
+	* 获取数据字段
+	* Data is stored as List(UInt8) without NUL terminator
+	* @param pointerIndex - The index of the pointer in the pointer section
+	* @returns Uint8Array of the data content, or undefined if null pointer
+	*/
+	getData(pointerIndex) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const resolved = this.message.resolvePointer(this.segmentIndex, ptrOffset);
+		if (!resolved) return void 0;
+		const { segmentIndex, wordOffset, pointer } = resolved;
+		if (pointer.tag !== PointerTag.LIST) return void 0;
+		const listPtr = pointer;
+		const segment = this.message.getSegment(segmentIndex);
+		const byteLength = listPtr.elementCount;
+		if (byteLength === 0) return new Uint8Array(0);
+		const bytes = new Uint8Array(segment.dataView.buffer, wordOffset * WORD_SIZE, byteLength);
+		return new Uint8Array(bytes);
+	}
+	/**
+	* 获取嵌套结构
+	*/
+	getStruct(pointerIndex, _dataWords, _pointerCount) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const resolved = this.message.resolvePointer(this.segmentIndex, ptrOffset);
+		if (!resolved) return void 0;
+		const { segmentIndex, wordOffset, pointer } = resolved;
+		if (pointer.tag !== PointerTag.STRUCT) return void 0;
+		const structPtr = pointer;
+		return new StructReader(this.message, segmentIndex, wordOffset, structPtr.dataWords, structPtr.pointerCount);
+	}
+	/**
+	* 获取列表
+	*/
+	getList(pointerIndex, _elementSize, structSize) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const resolved = this.message.resolvePointer(this.segmentIndex, ptrOffset);
+		if (!resolved) return void 0;
+		const { segmentIndex, wordOffset, pointer } = resolved;
+		if (pointer.tag !== PointerTag.LIST) return void 0;
+		const listPtr = pointer;
+		let targetOffset = wordOffset;
+		let elementCount = listPtr.elementCount;
+		let actualStructSize = structSize;
+		const segment = this.message.getSegment(segmentIndex);
+		if (listPtr.elementSize === ElementSize.COMPOSITE) {
+			if (targetOffset < 0 || targetOffset >= segment.wordCount) return;
+			try {
+				const tagWord = segment.getWord(targetOffset);
+				elementCount = Number(tagWord & BigInt(4294967295));
+				actualStructSize = {
+					dataWords: Number(tagWord >> BigInt(32) & BigInt(65535)),
+					pointerCount: Number(tagWord >> BigInt(48) & BigInt(65535))
+				};
+				targetOffset += 1;
+			} catch {
+				return;
+			}
+		}
+		return new ListReader(this.message, segmentIndex, listPtr.elementSize, elementCount, actualStructSize, targetOffset);
+	}
+};
+
+//#endregion
+export { MessageBuilder as n, MessageReader as t };
+//# sourceMappingURL=message-reader-_TCBf61G.js.map