@statewalker/webrun-msgpack 0.2.2 → 0.3.2

package/dist/index.js

@@ -1,13 +1,540 @@
-import msgpack from "@ygoe/msgpack";
+//#region src/msgpack-core.ts
+/*!
+* MessagePack serializer and deserializer.
+*
+* A TypeScript port of msgpack.js by Yves Goergen:
+*   https://github.com/ygoe/msgpack.js
+*   ported from commit 05733cfb43a2974cf669f0eb8693f43b548bdcd4 (2024-04-16) on `master`,
+*   which carries three fixes that the last npm release, `@ygoe/msgpack@1.0.3`, does not.
+* Every change made to the upstream logic is listed in this package's README, section
+* "Provenance and credits".
+*
+* Original work: Copyright © 2019, Yves Goergen, https://unclassified.software/source/msgpack-js
+* TypeScript port and modifications: Copyright (c) 2026 statewalker
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+* associated documentation files (the “Software”), to deal in the Software without restriction,
+* including without limitation the rights to use, copy, modify, merge, publish, distribute,
+* sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in all copies or
+* substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+* NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+const pow32 = 4294967296;
+/**
+* Serializes a value to a MessagePack byte array.
+*
+* The result is a view over a larger internal buffer; send the view, not its `.buffer`.
+*/
+function serialize(data, options) {
+	if (options?.multiple && !Array.isArray(data)) throw new Error("Invalid argument type: Expected an Array to serialize multiple values.");
+	let floatBuffer;
+	let floatView;
+	let array = /* @__PURE__ */ new Uint8Array(128);
+	let length = 0;
+	if (options?.multiple) {
+		const values = data;
+		for (let i = 0; i < values.length; i++) append(values[i]);
+	} else append(data);
+	return array.subarray(0, length);
+	function append(data, isReplacement) {
+		switch (typeof data) {
+			case "undefined":
+				appendNull();
+				break;
+			case "boolean":
+				appendBoolean(data);
+				break;
+			case "number":
+				appendNumber(data);
+				break;
+			case "string":
+				appendString(data);
+				break;
+			case "object":
+				if (data === null) appendNull();
+				else if (data instanceof Date) appendDate(data);
+				else if (Array.isArray(data)) appendArray(data);
+				else if (data instanceof Uint8Array || data instanceof Uint8ClampedArray) appendBinArray(data);
+				else if (data instanceof Int8Array || data instanceof Int16Array || data instanceof Uint16Array || data instanceof Int32Array || data instanceof Uint32Array || data instanceof Float32Array || data instanceof Float64Array) appendArray(data);
+				else appendObject(data);
+				break;
+			default: {
+				const replacement = options?.invalidTypeReplacement;
+				if (!isReplacement && options && replacement) {
+					if (typeof replacement === "function") append(replacement(data), true);
+					else append(replacement, true);
+				} else throw new Error(`Invalid argument type: The type '${typeof data}' cannot be serialized.`);
+			}
+		}
+	}
+	function appendNull() {
+		appendByte(192);
+	}
+	function appendBoolean(data) {
+		appendByte(data ? 195 : 194);
+	}
+	function appendNumber(data) {
+		if (Number.isFinite(data) && Number.isSafeInteger(data)) {
+			if (data >= 0 && data <= 127) appendByte(data);
+			else if (data < 0 && data >= -32) appendByte(data);
+			else if (data > 0 && data <= 255) appendBytes([204, data]);
+			else if (data >= -128 && data <= 127) appendBytes([208, data]);
+			else if (data > 0 && data <= 65535) appendBytes([
+				205,
+				data >>> 8,
+				data
+			]);
+			else if (data >= -32768 && data <= 32767) appendBytes([
+				209,
+				data >>> 8,
+				data
+			]);
+			else if (data > 0 && data <= 4294967295) appendBytes([
+				206,
+				data >>> 24,
+				data >>> 16,
+				data >>> 8,
+				data
+			]);
+			else if (data >= -2147483648 && data <= 2147483647) appendBytes([
+				210,
+				data >>> 24,
+				data >>> 16,
+				data >>> 8,
+				data
+			]);
+			else if (data > 0 && data <= 2 ** 64) {
+				appendByte(207);
+				appendInt64(data);
+			} else if (data >= -(2 ** 63) && data <= 2 ** 63) {
+				appendByte(211);
+				appendInt64(data);
+			} else if (data < 0) appendBytes([
+				211,
+				128,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			]);
+			else appendBytes([
+				207,
+				255,
+				255,
+				255,
+				255,
+				255,
+				255,
+				255,
+				255
+			]);
+		} else {
+			if (!floatView || !floatBuffer) {
+				floatBuffer = /* @__PURE__ */ new ArrayBuffer(8);
+				floatView = new DataView(floatBuffer);
+			}
+			floatView.setFloat64(0, data);
+			appendByte(203);
+			appendBytes(new Uint8Array(floatBuffer));
+		}
+	}
+	function appendString(data) {
+		const bytes = encodeUtf8(data);
+		const length = bytes.length;
+		if (length <= 31) appendByte(160 + length);
+		else if (length <= 255) appendBytes([217, length]);
+		else if (length <= 65535) appendBytes([
+			218,
+			length >>> 8,
+			length
+		]);
+		else appendBytes([
+			219,
+			length >>> 24,
+			length >>> 16,
+			length >>> 8,
+			length
+		]);
+		appendBytes(bytes);
+	}
+	function appendArray(data) {
+		const length = data.length;
+		if (length <= 15) appendByte(144 + length);
+		else if (length <= 65535) appendBytes([
+			220,
+			length >>> 8,
+			length
+		]);
+		else appendBytes([
+			221,
+			length >>> 24,
+			length >>> 16,
+			length >>> 8,
+			length
+		]);
+		for (let index = 0; index < length; index++) append(data[index]);
+	}
+	function appendBinArray(data) {
+		const length = data.length;
+		if (length <= 255) appendBytes([196, length]);
+		else if (length <= 65535) appendBytes([
+			197,
+			length >>> 8,
+			length
+		]);
+		else appendBytes([
+			198,
+			length >>> 24,
+			length >>> 16,
+			length >>> 8,
+			length
+		]);
+		appendBytes(data);
+	}
+	function appendObject(data) {
+		const keys = Object.keys(data);
+		let length = 0;
+		for (const key of keys) if (data[key] !== void 0) length++;
+		if (length <= 15) appendByte(128 + length);
+		else if (length <= 65535) appendBytes([
+			222,
+			length >>> 8,
+			length
+		]);
+		else appendBytes([
+			223,
+			length >>> 24,
+			length >>> 16,
+			length >>> 8,
+			length
+		]);
+		for (const key of keys) {
+			const value = data[key];
+			if (value !== void 0) {
+				append(key);
+				append(value);
+			}
+		}
+	}
+	function appendDate(data) {
+		const time = data.getTime();
+		if (Number.isNaN(time)) throw new Error("Invalid argument: an invalid Date cannot be serialized.");
+		const sec = Math.floor(time / 1e3);
+		const ns = (time - sec * 1e3) * 1e6;
+		if (ns === 0 && sec >= 0 && sec < 4294967296) appendBytes([
+			214,
+			255,
+			sec >>> 24,
+			sec >>> 16,
+			sec >>> 8,
+			sec
+		]);
+		else if (sec >= 0 && sec < 17179869184) appendBytes([
+			215,
+			255,
+			ns >>> 22,
+			ns >>> 14,
+			ns >>> 6,
+			ns << 2 >>> 0 | sec / pow32,
+			sec >>> 24,
+			sec >>> 16,
+			sec >>> 8,
+			sec
+		]);
+		else {
+			appendBytes([
+				199,
+				12,
+				255,
+				ns >>> 24,
+				ns >>> 16,
+				ns >>> 8,
+				ns
+			]);
+			appendInt64(sec);
+		}
+	}
+	function appendByte(byte) {
+		if (array.length < length + 1) {
+			let newLength = array.length * 2;
+			while (newLength < length + 1) newLength *= 2;
+			const newArray = new Uint8Array(newLength);
+			newArray.set(array);
+			array = newArray;
+		}
+		array[length] = byte;
+		length++;
+	}
+	function appendBytes(bytes) {
+		if (array.length < length + bytes.length) {
+			let newLength = array.length * 2;
+			while (newLength < length + bytes.length) newLength *= 2;
+			const newArray = new Uint8Array(newLength);
+			newArray.set(array);
+			array = newArray;
+		}
+		array.set(bytes, length);
+		length += bytes.length;
+	}
+	function appendInt64(value) {
+		let hi;
+		let lo;
+		if (value >= 0) {
+			hi = value / pow32;
+			lo = value % pow32;
+		} else {
+			value++;
+			hi = Math.abs(value) / pow32;
+			lo = Math.abs(value) % pow32;
+			hi = ~hi;
+			lo = ~lo;
+		}
+		appendBytes([
+			hi >>> 24,
+			hi >>> 16,
+			hi >>> 8,
+			hi,
+			lo >>> 24,
+			lo >>> 16,
+			lo >>> 8,
+			lo
+		]);
+	}
+}
+/**
+* Deserializes a MessagePack byte array to a value.
+*
+* `bin` values are returned as `Uint8Array` views into the input, not copies.
+*/
+function deserialize(input, options) {
+	let pos = 0;
+	let array;
+	if (input instanceof Uint8Array) array = input;
+	else if (input instanceof ArrayBuffer) array = new Uint8Array(input);
+	else if (typeof input !== "object" || input === null || typeof input.length === "undefined") throw new Error("Invalid argument type: Expected a byte array (Array or Uint8Array) to deserialize.");
+	else array = new Uint8Array(input);
+	if (!array.length) throw new Error("Invalid argument: The byte array to deserialize is empty.");
+	let data;
+	if (options?.multiple) {
+		const values = [];
+		while (pos < array.length) values.push(read());
+		data = values;
+	} else data = read();
+	return data;
+	function need(size) {
+		if (pos + size > array.length) throw new RangeError(`Insufficient data: ${size} byte(s) needed at index ${pos} in the MessagePack binary data (length ${array.length}).`);
+	}
+	function read() {
+		need(1);
+		const byte = array[pos++];
+		if (byte >= 0 && byte <= 127) return byte;
+		if (byte >= 128 && byte <= 143) return readMap(byte - 128);
+		if (byte >= 144 && byte <= 159) return readArray(byte - 144);
+		if (byte >= 160 && byte <= 191) return readStr(byte - 160);
+		if (byte === 192) return null;
+		if (byte === 193) throw new Error("Invalid byte code 0xc1 found.");
+		if (byte === 194) return false;
+		if (byte === 195) return true;
+		if (byte === 196) return readBin(-1, 1);
+		if (byte === 197) return readBin(-1, 2);
+		if (byte === 198) return readBin(-1, 4);
+		if (byte === 199) return readExt(-1, 1);
+		if (byte === 200) return readExt(-1, 2);
+		if (byte === 201) return readExt(-1, 4);
+		if (byte === 202) return readFloat(4);
+		if (byte === 203) return readFloat(8);
+		if (byte === 204) return readUInt(1);
+		if (byte === 205) return readUInt(2);
+		if (byte === 206) return readUInt(4);
+		if (byte === 207) return readUInt(8);
+		if (byte === 208) return readInt(1);
+		if (byte === 209) return readInt(2);
+		if (byte === 210) return readInt(4);
+		if (byte === 211) return readInt(8);
+		if (byte === 212) return readExt(1);
+		if (byte === 213) return readExt(2);
+		if (byte === 214) return readExt(4);
+		if (byte === 215) return readExt(8);
+		if (byte === 216) return readExt(16);
+		if (byte === 217) return readStr(-1, 1);
+		if (byte === 218) return readStr(-1, 2);
+		if (byte === 219) return readStr(-1, 4);
+		if (byte === 220) return readArray(-1, 2);
+		if (byte === 221) return readArray(-1, 4);
+		if (byte === 222) return readMap(-1, 2);
+		if (byte === 223) return readMap(-1, 4);
+		if (byte >= 224 && byte <= 255) return byte - 256;
+		throw new Error(`Invalid byte value '${byte}' at index ${pos - 1} in the MessagePack binary data (length ${array.length}): Expecting a range of 0 to 255. This is not a byte array.`);
+	}
+	function readInt(size) {
+		need(size);
+		let value = 0;
+		let first = true;
+		while (size-- > 0) if (first) {
+			const byte = array[pos++];
+			value += byte & 127;
+			if (byte & 128) value -= 128;
+			first = false;
+		} else {
+			value *= 256;
+			value += array[pos++];
+		}
+		return value;
+	}
+	function readUInt(size) {
+		need(size);
+		let value = 0;
+		while (size-- > 0) {
+			value *= 256;
+			value += array[pos++];
+		}
+		return value;
+	}
+	function readFloat(size) {
+		need(size);
+		const view = new DataView(array.buffer, pos + array.byteOffset, size);
+		pos += size;
+		return size === 4 ? view.getFloat32(0, false) : view.getFloat64(0, false);
+	}
+	function readBin(size, lengthSize) {
+		if (size < 0) size = readUInt(lengthSize);
+		need(size);
+		const data = array.subarray(pos, pos + size);
+		pos += size;
+		return data;
+	}
+	function readMap(size, lengthSize) {
+		if (size < 0) size = readUInt(lengthSize);
+		const data = {};
+		while (size-- > 0) {
+			const key = String(read());
+			const value = read();
+			if (key === "__proto__") Object.defineProperty(data, key, {
+				value,
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+			else data[key] = value;
+		}
+		return data;
+	}
+	function readArray(size, lengthSize) {
+		if (size < 0) size = readUInt(lengthSize);
+		const data = [];
+		while (size-- > 0) data.push(read());
+		return data;
+	}
+	function readStr(size, lengthSize) {
+		if (size < 0) size = readUInt(lengthSize);
+		need(size);
+		const start = pos;
+		pos += size;
+		return decodeUtf8(array, start, size);
+	}
+	function readExt(size, lengthSize) {
+		if (size < 0) size = readUInt(lengthSize);
+		const type = readUInt(1);
+		const data = readBin(size);
+		switch (type) {
+			case 255: return readExtDate(data);
+		}
+		return {
+			type,
+			data
+		};
+	}
+	function readExtDate(data) {
+		const b = (i) => data[i];
+		if (data.length === 4) {
+			const sec = (b(0) << 24 >>> 0) + (b(1) << 16 >>> 0) + (b(2) << 8 >>> 0) + b(3);
+			return /* @__PURE__ */ new Date(sec * 1e3);
+		}
+		if (data.length === 8) {
+			const ns = (b(0) << 22 >>> 0) + (b(1) << 14 >>> 0) + (b(2) << 6 >>> 0) + (b(3) >>> 2);
+			const sec = (b(3) & 3) * pow32 + (b(4) << 24 >>> 0) + (b(5) << 16 >>> 0) + (b(6) << 8 >>> 0) + b(7);
+			return new Date(sec * 1e3 + Math.floor(ns / 1e6));
+		}
+		if (data.length === 12) {
+			const ns = (b(0) << 24 >>> 0) + (b(1) << 16 >>> 0) + (b(2) << 8 >>> 0) + b(3);
+			pos -= 8;
+			const sec = readInt(8);
+			return new Date(sec * 1e3 + Math.floor(ns / 1e6));
+		}
+		throw new Error("Invalid data length for a date value.");
+	}
+}
+/** Encodes a string to UTF-8 bytes. */
+function encodeUtf8(str) {
+	let ascii = true;
+	const length = str.length;
+	for (let x = 0; x < length; x++) if (str.charCodeAt(x) > 127) {
+		ascii = false;
+		break;
+	}
+	let i = 0;
+	const bytes = new Uint8Array(str.length * (ascii ? 1 : 4));
+	for (let ci = 0; ci !== length; ci++) {
+		let c = str.charCodeAt(ci);
+		if (c < 128) {
+			bytes[i++] = c;
+			continue;
+		}
+		if (c < 2048) bytes[i++] = c >> 6 | 192;
+		else {
+			const c2 = c > 55295 && c < 56320 && ci + 1 < length ? str.charCodeAt(ci + 1) : 0;
+			if (c2 >= 56320 && c2 <= 57343) {
+				ci++;
+				c = 65536 + ((c & 1023) << 10) + (c2 & 1023);
+				bytes[i++] = c >> 18 | 240;
+				bytes[i++] = c >> 12 & 63 | 128;
+			} else {
+				if (c > 55295 && c < 57344) c = 65533;
+				bytes[i++] = c >> 12 | 224;
+			}
+			bytes[i++] = c >> 6 & 63 | 128;
+		}
+		bytes[i++] = c & 63 | 128;
+	}
+	return ascii ? bytes : bytes.subarray(0, i);
+}
+const utf8Decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+/** Decodes a string from UTF-8 bytes. */
+function decodeUtf8(bytes, start, length) {
+	const end = start + length;
+	if (length <= 12) {
+		let str = "";
+		for (let i = start; i < end; i++) {
+			const c = bytes[i];
+			if (c > 127) return utf8Decoder.decode(bytes.subarray(start, end));
+			str += String.fromCharCode(c);
+		}
+		return str;
+	}
+	return utf8Decoder.decode(bytes.subarray(start, end));
+}
+//#endregion
 //#region src/msgpack.ts
-const { serialize: serialize$1, deserialize: deserialize$1 } = msgpack;
 /**
 * Encode each value as a length-prefixed msgpack frame.
 * Frame format: [4-byte big-endian length][msgpack bytes]
+*
+* The input may be synchronous (an array, a generator) or asynchronous.
 */
 async function* encodeMsgpack(input) {
 	for await (const item of input) {
-		const payload = serialize$1(item);
+		const payload = serialize(item);
 		const frame = new Uint8Array(4 + payload.length);
 		new DataView(frame.buffer).setUint32(0, payload.length, false);
 		frame.set(payload, 4);
@@ -16,6 +543,8 @@ async function* encodeMsgpack(input) {
 }
 /**
 * Decode length-prefixed msgpack frames, reassembling across chunk boundaries.
+*
+* The input may be synchronous (an array of chunks) or asynchronous.
 */
 async function* decodeMsgpack(input) {
 	let buffer = /* @__PURE__ */ new Uint8Array(0);
@@ -26,18 +555,19 @@ async function* decodeMsgpack(input) {
 			if (buffer.length < 4 + frameLen) break;
 			const payload = buffer.subarray(4, 4 + frameLen);
 			buffer = buffer.subarray(4 + frameLen);
-			yield deserialize$1(Uint8Array.from(payload));
+			yield deserialize(Uint8Array.from(payload));
 		}
 	}
 }
 /**
 * Encode each Float32Array as a msgpack frame.
 * The Float32Array is converted to a Uint8Array view (zero-copy) before encoding as msgpack bin.
+*
+* The input may be synchronous (an array, a generator) or asynchronous.
 */
 async function* encodeFloat32Arrays(input) {
 	for await (const arr of input) {
-		const bytes = new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
-		const payload = serialize$1(bytes);
+		const payload = serialize(new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength));
 		const frame = new Uint8Array(4 + payload.length);
 		new DataView(frame.buffer).setUint32(0, payload.length, false);
 		frame.set(payload, 4);
@@ -47,9 +577,11 @@ async function* encodeFloat32Arrays(input) {
 /**
 * Decode msgpack frames back to Float32Array.
 * Each frame contains a msgpack bin value (Uint8Array), reinterpreted as Float32Array.
+*
+* The input may be synchronous (an array of chunks) or asynchronous.
 */
 async function* decodeFloat32Arrays(input) {
-	for await (const item of decodeMsgpack(wrapIterable(input))) {
+	for await (const item of decodeMsgpack(input)) {
 		const aligned = alignBuffer(item);
 		yield new Float32Array(aligned.buffer, aligned.byteOffset, aligned.byteLength / 4);
 	}
@@ -67,12 +599,8 @@ function concat(a, b) {
 	result.set(b, a.length);
 	return result;
 }
-async function* wrapIterable(input) {
-	yield* input;
-}
 //#endregion
 //#region src/port-codec.ts
-const { serialize, deserialize } = msgpack;
 /**
 * Same shape check as `structuredCodec`'s, applied after decoding. A shared
 * transport carries traffic that is not ours, and layer 1 must not mistake it
@@ -130,4 +658,4 @@ const msgpackCodec = {
 	}
 };
 //#endregion
-export { decodeFloat32Arrays, decodeMsgpack, encodeFloat32Arrays, encodeMsgpack, msgpackCodec };
+export { decodeFloat32Arrays, decodeMsgpack, deserialize, encodeFloat32Arrays, encodeMsgpack, msgpackCodec, serialize };

package/dist/msgpack-core.d.ts

@@ -0,0 +1,70 @@
+/*!
+ * MessagePack serializer and deserializer.
+ *
+ * A TypeScript port of msgpack.js by Yves Goergen:
+ *   https://github.com/ygoe/msgpack.js
+ *   ported from commit 05733cfb43a2974cf669f0eb8693f43b548bdcd4 (2024-04-16) on `master`,
+ *   which carries three fixes that the last npm release, `@ygoe/msgpack@1.0.3`, does not.
+ * Every change made to the upstream logic is listed in this package's README, section
+ * "Provenance and credits".
+ *
+ * Original work: Copyright © 2019, Yves Goergen, https://unclassified.software/source/msgpack-js
+ * TypeScript port and modifications: Copyright (c) 2026 statewalker
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+ * associated documentation files (the “Software”), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+ * NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+/** Options for {@link serialize}. */
+export interface SerializeOptions {
+    /**
+     * Treat `data` as an array of values and concatenate their encodings, one MessagePack document
+     * after another, instead of encoding the array itself. Default: `false`.
+     */
+    multiple?: boolean;
+    /**
+     * What to write in place of a value whose type cannot be serialized (a function, a symbol, a
+     * bigint): either the replacement value itself, or a function that returns one given the
+     * original. When absent, such a value throws.
+     */
+    invalidTypeReplacement?: unknown;
+}
+/** Options for {@link deserialize}. */
+export interface DeserializeOptions {
+    /**
+     * Read every concatenated MessagePack document in the input and return them as an array.
+     * Default: `false` — read one document and ignore any bytes after it.
+     */
+    multiple?: boolean;
+}
+/** The byte shapes {@link deserialize} accepts. */
+export type MsgpackInput = Uint8Array | ArrayBuffer | ArrayLike<number>;
+/** An extension value whose type this implementation does not interpret (anything but a timestamp). */
+export interface MsgpackExtension {
+    type: number;
+    data: Uint8Array;
+}
+/**
+ * Serializes a value to a MessagePack byte array.
+ *
+ * The result is a view over a larger internal buffer; send the view, not its `.buffer`.
+ */
+export declare function serialize(data: unknown, options?: SerializeOptions): Uint8Array<ArrayBuffer>;
+/**
+ * Deserializes a MessagePack byte array to a value.
+ *
+ * `bin` values are returned as `Uint8Array` views into the input, not copies.
+ */
+export declare function deserialize(input: MsgpackInput, options?: DeserializeOptions): unknown;
+//# sourceMappingURL=msgpack-core.d.ts.map

package/dist/msgpack-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"msgpack-core.d.ts","sourceRoot":"","sources":["../src/msgpack-core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,qCAAqC;AACrC,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,mDAAmD;AACnD,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,WAAW,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AAExE,uGAAuG;AACvG,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;CAClB;AAID;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,UAAU,CAAC,WAAW,CAAC,CAmQ5F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAoNtF"}