@naeemo/capnp 0.8.1 → 0.9.0

package/dist/message-reader-fw2PY8sU.js

@@ -0,0 +1,848 @@
+#!/usr/bin/env node
+//#region src/core/pointer.ts
+/**
+* Cap'n Proto 指针编解码
+* 纯 TypeScript 实现
+*/
+let PointerTag = /* @__PURE__ */ function(PointerTag) {
+	PointerTag[PointerTag["STRUCT"] = 0] = "STRUCT";
+	PointerTag[PointerTag["LIST"] = 1] = "LIST";
+	PointerTag[PointerTag["FAR"] = 2] = "FAR";
+	PointerTag[PointerTag["OTHER"] = 3] = "OTHER";
+	return PointerTag;
+}({});
+let ElementSize = /* @__PURE__ */ function(ElementSize) {
+	ElementSize[ElementSize["VOID"] = 0] = "VOID";
+	ElementSize[ElementSize["BIT"] = 1] = "BIT";
+	ElementSize[ElementSize["BYTE"] = 2] = "BYTE";
+	ElementSize[ElementSize["TWO_BYTES"] = 3] = "TWO_BYTES";
+	ElementSize[ElementSize["FOUR_BYTES"] = 4] = "FOUR_BYTES";
+	ElementSize[ElementSize["EIGHT_BYTES"] = 5] = "EIGHT_BYTES";
+	ElementSize[ElementSize["POINTER"] = 6] = "POINTER";
+	ElementSize[ElementSize["COMPOSITE"] = 7] = "COMPOSITE";
+	ElementSize[ElementSize["INLINE_COMPOSITE"] = 7] = "INLINE_COMPOSITE";
+	return ElementSize;
+}({});
+/**
+* 解码指针（64位）
+*/
+function decodePointer(ptr) {
+	const tag = Number(ptr & BigInt(3));
+	switch (tag) {
+		case PointerTag.STRUCT: {
+			const offset = Number(ptr >> BigInt(2)) & 1073741823;
+			return {
+				tag,
+				offset: offset >= 536870912 ? offset - 1073741824 : offset,
+				dataWords: Number(ptr >> BigInt(32) & BigInt(65535)),
+				pointerCount: Number(ptr >> BigInt(48) & BigInt(65535))
+			};
+		}
+		case PointerTag.LIST: {
+			const offset = Number(ptr >> BigInt(2)) & 1073741823;
+			return {
+				tag,
+				offset: offset >= 536870912 ? offset - 1073741824 : offset,
+				elementSize: Number(ptr >> BigInt(32) & BigInt(7)),
+				elementCount: Number(ptr >> BigInt(35) & BigInt(536870911))
+			};
+		}
+		case PointerTag.FAR: {
+			const doubleFar = Boolean(ptr >> BigInt(2) & BigInt(1));
+			const targetOffset = Number(ptr >> BigInt(3) & BigInt(536870911));
+			return {
+				tag,
+				doubleFar,
+				targetSegment: Number(ptr >> BigInt(32) & BigInt(4294967295)),
+				targetOffset
+			};
+		}
+		default: return { tag: PointerTag.OTHER };
+	}
+}
+/**
+* 编码 Struct 指针
+*/
+function encodeStructPointer(offset, dataWords, pointerCount) {
+	return (BigInt(offset < 0 ? offset + 1073741824 : offset) & BigInt(1073741823)) << BigInt(2) | BigInt(dataWords) << BigInt(32) | BigInt(pointerCount) << BigInt(48);
+}
+/**
+* 编码 List 指针
+*/
+function encodeListPointer(offset, elementSize, elementCount) {
+	return (BigInt(offset < 0 ? offset + 1073741824 : offset) & BigInt(1073741823)) << BigInt(2) | BigInt(1) | BigInt(elementSize) << BigInt(32) | BigInt(elementCount) << BigInt(35);
+}
+
+//#endregion
+//#region src/core/segment.ts
+/**
+* Cap'n Proto Segment 管理
+* 纯 TypeScript 实现
+*/
+const WORD_SIZE = 8;
+var Segment = class Segment {
+	buffer;
+	view;
+	_size;
+	constructor(initialCapacity = 1024) {
+		this.buffer = new ArrayBuffer(initialCapacity);
+		this.view = new DataView(this.buffer);
+		this._size = 0;
+	}
+	/**
+	* 从现有 buffer 创建（用于读取）
+	*/
+	static fromBuffer(buffer) {
+		const seg = new Segment(0);
+		seg.buffer = buffer;
+		seg.view = new DataView(buffer);
+		seg._size = buffer.byteLength;
+		return seg;
+	}
+	/**
+	* 确保容量足够
+	*/
+	ensureCapacity(minBytes) {
+		if (this.buffer.byteLength >= minBytes) return;
+		let newCapacity = this.buffer.byteLength * 2;
+		while (newCapacity < minBytes) newCapacity *= 2;
+		const newBuffer = new ArrayBuffer(newCapacity);
+		new Uint8Array(newBuffer).set(new Uint8Array(this.buffer, 0, this._size));
+		this.buffer = newBuffer;
+		this.view = new DataView(newBuffer);
+	}
+	/**
+	* 分配空间，返回字偏移
+	*/
+	allocate(words) {
+		const bytes = words * WORD_SIZE;
+		const offset = this._size;
+		this.ensureCapacity(offset + bytes);
+		this._size = offset + bytes;
+		return offset / WORD_SIZE;
+	}
+	/**
+	* 获取字（64位）
+	*/
+	getWord(wordOffset) {
+		const byteOffset = wordOffset * WORD_SIZE;
+		if (byteOffset + 8 > this._size) throw new Error(`Offset ${wordOffset} is outside the bounds of the segment (${this.wordCount} words)`);
+		const low = BigInt(this.view.getUint32(byteOffset, true));
+		return BigInt(this.view.getUint32(byteOffset + 4, true)) << BigInt(32) | low;
+	}
+	/**
+	* 设置字（64位）
+	*/
+	setWord(wordOffset, value) {
+		const byteOffset = wordOffset * WORD_SIZE;
+		if (byteOffset + 8 > this.buffer.byteLength) throw new Error(`Offset ${wordOffset} is outside the bounds of the segment`);
+		this.view.setUint32(byteOffset, Number(value & BigInt(4294967295)), true);
+		this.view.setUint32(byteOffset + 4, Number(value >> BigInt(32)), true);
+	}
+	/**
+	* 获取原始 buffer（只读到 _size）
+	*/
+	asUint8Array() {
+		return new Uint8Array(this.buffer, 0, this._size);
+	}
+	/**
+	* 获取底层 ArrayBuffer
+	*/
+	getArrayBuffer() {
+		return this.buffer;
+	}
+	/**
+	* 获取字数量
+	*/
+	get wordCount() {
+		return this._size / WORD_SIZE;
+	}
+	/**
+	* 获取字节数量
+	*/
+	get byteLength() {
+		return this._size;
+	}
+	/**
+	* 获取 DataView
+	*/
+	get dataView() {
+		return this.view;
+	}
+};
+
+//#endregion
+//#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 实现
+*/
+var MessageReader = class {
+	segments;
+	constructor(buffer) {
+		const uint8Array = buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer;
+		this.segments = [];
+		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;
+		let offset = 8;
+		const segmentSizes = [firstSegmentSize];
+		for (let i = 1; i < segmentCount; i++) {
+			if (offset + 4 > uint8Array.byteLength) {
+				this.segments = [];
+				return;
+			}
+			segmentSizes.push(view.getUint32(offset, true));
+			offset += 4;
+		}
+		offset = offset + 7 & -8;
+		if (offset > uint8Array.byteLength) {
+			this.segments = [];
+			return;
+		}
+		this.segments = [];
+		for (const size of segmentSizes) {
+			if (offset + size * WORD_SIZE > uint8Array.byteLength) 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;
+	}
+};
+/**
+* 结构读取器
+*/
+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, ElementSize as r, MessageReader as t };
+//# sourceMappingURL=message-reader-fw2PY8sU.js.map