@naeemo/capnp 0.1.0

package/dist/index.cjs

@@ -0,0 +1,765 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#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";
+	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;
+		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;
+		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);
+	}
+	/**
+	* 获取字数量
+	*/
+	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);
+	}
+	/**
+	* 初始化嵌套结构
+	*/
+	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;
+	constructor(message, segmentIndex, elementSize, elementCount, structSize, wordOffset) {
+		this.message = message;
+		this.elementSize = elementSize;
+		this.elementCount = elementCount;
+		this.structSize = structSize;
+		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, 0, 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) throw new Error("Root pointer is not a struct");
+		const structPtr = ptr;
+		const dataOffset = 1 + structPtr.offset;
+		return new StructReader(this, 0, dataOffset, structPtr.dataWords, structPtr.pointerCount);
+	}
+	/**
+	* 获取段
+	*/
+	getSegment(index) {
+		return this.segments[index];
+	}
+	/**
+	* 段数量
+	*/
+	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;
+		return (this.message.getSegment(this.segmentIndex).dataView.getUint8(this.wordOffset * WORD_SIZE + byteOffset) & 1 << bitInByte) !== 0;
+	}
+	/**
+	* 获取 int8 字段
+	*/
+	getInt8(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getInt8(this.wordOffset * WORD_SIZE + byteOffset);
+	}
+	/**
+	* 获取 int16 字段
+	*/
+	getInt16(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getInt16(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 int32 字段
+	*/
+	getInt32(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getInt32(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 int64 字段
+	*/
+	getInt64(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const offset = this.wordOffset * WORD_SIZE + byteOffset;
+		const low = BigInt(segment.dataView.getUint32(offset, true));
+		return BigInt(segment.dataView.getInt32(offset + 4, true)) << BigInt(32) | low;
+	}
+	/**
+	* 获取 uint8 字段
+	*/
+	getUint8(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getUint8(this.wordOffset * WORD_SIZE + byteOffset);
+	}
+	/**
+	* 获取 uint16 字段
+	*/
+	getUint16(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getUint16(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 uint32 字段
+	*/
+	getUint32(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getUint32(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 uint64 字段
+	*/
+	getUint64(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const offset = this.wordOffset * WORD_SIZE + byteOffset;
+		const low = BigInt(segment.dataView.getUint32(offset, true));
+		return BigInt(segment.dataView.getUint32(offset + 4, true)) << BigInt(32) | low;
+	}
+	/**
+	* 获取 float32 字段
+	*/
+	getFloat32(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getFloat32(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 float64 字段
+	*/
+	getFloat64(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getFloat64(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取文本字段
+	*/
+	getText(pointerIndex) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const segment = this.message.getSegment(this.segmentIndex);
+		const ptrValue = segment.getWord(ptrOffset);
+		if (ptrValue === 0n) return "";
+		const ptr = decodePointer(ptrValue);
+		if (ptr.tag !== PointerTag.LIST) return "";
+		const listPtr = ptr;
+		const targetOffset = ptrOffset + 1 + listPtr.offset;
+		const bytes = new Uint8Array(segment.dataView.buffer, targetOffset * WORD_SIZE, listPtr.elementCount - 1);
+		return new TextDecoder().decode(bytes);
+	}
+	/**
+	* 获取嵌套结构
+	*/
+	getStruct(pointerIndex, _dataWords, _pointerCount) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const ptrValue = this.message.getSegment(this.segmentIndex).getWord(ptrOffset);
+		if (ptrValue === 0n) return void 0;
+		const ptr = decodePointer(ptrValue);
+		if (ptr.tag !== PointerTag.STRUCT) return void 0;
+		const structPtr = ptr;
+		const targetOffset = ptrOffset + 1 + structPtr.offset;
+		return new StructReader(this.message, this.segmentIndex, targetOffset, structPtr.dataWords, structPtr.pointerCount);
+	}
+	/**
+	* 获取列表
+	*/
+	getList(pointerIndex, _elementSize, structSize) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const ptrValue = this.message.getSegment(this.segmentIndex).getWord(ptrOffset);
+		if (ptrValue === 0n) return void 0;
+		const ptr = decodePointer(ptrValue);
+		if (ptr.tag !== PointerTag.LIST) return void 0;
+		const listPtr = ptr;
+		const targetOffset = ptrOffset + 1 + listPtr.offset;
+		return new ListReader(this.message, this.segmentIndex, listPtr.elementSize, listPtr.elementCount, structSize, targetOffset);
+	}
+};
+
+//#endregion
+//#region src/core/union.ts
+/**
+* UnionReader - 读取 Union 的 tag 和 variant
+*/
+var UnionReader = class {
+	constructor(struct, tagOffset, variants) {
+		this.struct = struct;
+		this.tagOffset = tagOffset;
+		this.variants = variants;
+	}
+	/**
+	* 获取当前激活的 variant tag
+	*/
+	getTag() {
+		return this.struct.getUint16(this.tagOffset);
+	}
+	/**
+	* 获取当前激活的 variant 名称
+	*/
+	getVariantName() {
+		return this.variants.get(this.getTag());
+	}
+	/**
+	* 检查是否是某个 variant
+	*/
+	is(variantTag) {
+		return this.getTag() === variantTag;
+	}
+};
+/**
+* UnionBuilder - 设置 Union 的 tag 和 variant
+*/
+var UnionBuilder = class {
+	constructor(struct, tagOffset) {
+		this.struct = struct;
+		this.tagOffset = tagOffset;
+	}
+	/**
+	* 获取当前 tag
+	*/
+	getTag() {
+		return this.struct.getUint16(this.tagOffset);
+	}
+	/**
+	* 设置 tag
+	*/
+	setTag(tag) {
+		this.struct.setUint16(this.tagOffset, tag);
+	}
+	/**
+	* 初始化某个 variant（自动设置 tag）
+	*/
+	initVariant(tag, initFn) {
+		this.setTag(tag);
+		initFn();
+	}
+};
+/**
+* 创建 UnionReader 的工厂函数
+*/
+function createUnionReader(struct, tagOffset, variants) {
+	return new UnionReader(struct, tagOffset, new Map(Object.entries(variants).map(([k, v]) => [Number(k), v])));
+}
+/**
+* 创建 UnionBuilder 的工厂函数
+*/
+function createUnionBuilder(struct, tagOffset) {
+	return new UnionBuilder(struct, tagOffset);
+}
+
+//#endregion
+exports.ElementSize = ElementSize;
+exports.ListBuilder = ListBuilder;
+exports.ListReader = ListReader;
+exports.MessageBuilder = MessageBuilder;
+exports.MessageReader = MessageReader;
+exports.PointerTag = PointerTag;
+exports.Segment = Segment;
+exports.StructBuilder = StructBuilder;
+exports.StructReader = StructReader;
+exports.UnionBuilder = UnionBuilder;
+exports.UnionReader = UnionReader;
+exports.WORD_SIZE = WORD_SIZE;
+exports.createUnionBuilder = createUnionBuilder;
+exports.createUnionReader = createUnionReader;
+exports.decodePointer = decodePointer;
+exports.encodeListPointer = encodeListPointer;
+exports.encodeStructPointer = encodeStructPointer;
+//# sourceMappingURL=index.cjs.map