@hopple/netcode 0.0.0-stage → 0.1.0

package/shared-BR4Zxz2l.js

@@ -0,0 +1,185 @@
+//#region src/bytes.ts
+/**
+* Numbers and strings as bytes and back, exactly: what a game sends in a
+* match, written once and read the same way on every device.
+*
+* Integers are varints — a byte for anything under 128 — so a message of small
+* numbers stays small; floats are their eight bytes, little-endian, so they
+* arrive with every bit they left with; strings are UTF-8.
+*
+* ```ts
+* const out = new ByteWriter().uint(PICK).uint(fighter).bool(ready).finish();
+* match.send(out);
+*
+* const read = new ByteReader(data);
+* if (read.uint() === PICK) setPick(from, read.uint(), read.bool());
+* ```
+*
+* @module bytes
+*/
+const scratch = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+/**
+* Builds a message.
+*
+* @group Bytes
+*/
+var ByteWriter = class {
+	buffer = /* @__PURE__ */ new Uint8Array(64);
+	length = 0;
+	room(more) {
+		if (this.length + more <= this.buffer.length) return;
+		const grown = new Uint8Array(Math.max(this.buffer.length * 2, this.length + more));
+		grown.set(this.buffer.subarray(0, this.length));
+		this.buffer = grown;
+	}
+	/** One byte, 0..255. */
+	byte(value) {
+		this.room(1);
+		this.buffer[this.length++] = value & 255;
+		return this;
+	}
+	/** A whole number from 0 up to 2⁵³: one byte under 128, two under 16384, and so on. */
+	uint(value) {
+		if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`ByteWriter.uint: ${value} is not a whole number from 0 to 2^53.`);
+		this.room(8);
+		while (value >= 128) {
+			this.buffer[this.length++] = value % 128 | 128;
+			value = Math.floor(value / 128);
+		}
+		this.buffer[this.length++] = value;
+		return this;
+	}
+	/** An integer from −2⁵² up to, not including, 2⁵², small ones in a byte whichever their sign. */
+	int(value) {
+		if (!Number.isSafeInteger(value) || value < -4503599627370496 || value >= 4503599627370496) throw new RangeError(`ByteWriter.int: ${value} is not an integer from -2^52 up to 2^52.`);
+		return this.uint(value >= 0 ? value * 2 : -value * 2 - 1);
+	}
+	bool(value) {
+		return this.byte(value ? 1 : 0);
+	}
+	/** A number's eight bytes, exactly. */
+	float64(value) {
+		this.room(8);
+		scratch.setFloat64(0, value, true);
+		for (let i = 0; i < 8; i++) this.buffer[this.length++] = scratch.getUint8(i);
+		return this;
+	}
+	/** Bytes, after their length. */
+	bytes(value) {
+		this.uint(value.length);
+		this.room(value.length);
+		this.buffer.set(value, this.length);
+		this.length += value.length;
+		return this;
+	}
+	/** A string as UTF-8, after its length in bytes. A lone surrogate is written as U+FFFD. */
+	string(value) {
+		const encoded = [];
+		for (let i = 0; i < value.length; i++) {
+			let c = value.charCodeAt(i);
+			if (c >= 55296 && c <= 56319 && i + 1 < value.length) {
+				const d = value.charCodeAt(i + 1);
+				if (d >= 56320 && d <= 57343) {
+					c = 65536 + (c - 55296 << 10) + (d - 56320);
+					i++;
+				} else c = 65533;
+			} else if (c >= 55296 && c <= 57343) c = 65533;
+			if (c < 128) encoded.push(c);
+			else if (c < 2048) encoded.push(192 | c >> 6, 128 | c & 63);
+			else if (c < 65536) encoded.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+			else encoded.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+		}
+		return this.bytes(Uint8Array.from(encoded));
+	}
+	/** What has been written, as a message of its own. */
+	finish() {
+		return this.buffer.slice(0, this.length);
+	}
+};
+/**
+* Reads a message, in the order it was written. Reading past its end, or a
+* value that is not what it should be, throws a `RangeError`: a message from
+* another device is checked, not believed.
+*
+* @group Bytes
+*/
+var ByteReader = class {
+	at = 0;
+	data;
+	constructor(data) {
+		this.data = data;
+	}
+	/** Whether everything has been read. */
+	get done() {
+		return this.at >= this.data.length;
+	}
+	/** How many bytes are left. */
+	get left() {
+		return this.data.length - this.at;
+	}
+	byte() {
+		if (this.at >= this.data.length) throw new RangeError("ByteReader: read past the end.");
+		return this.data[this.at++];
+	}
+	uint() {
+		let value = 0;
+		let scale = 1;
+		for (let i = 0; i < 8; i++) {
+			const byte = this.byte();
+			value += (byte & 127) * scale;
+			if (byte < 128) {
+				if (!Number.isSafeInteger(value)) break;
+				return value;
+			}
+			scale *= 128;
+		}
+		throw new RangeError("ByteReader: not a whole number.");
+	}
+	int() {
+		const zigzag = this.uint();
+		return zigzag % 2 === 0 ? zigzag / 2 : -(zigzag + 1) / 2;
+	}
+	bool() {
+		const byte = this.byte();
+		if (byte > 1) throw new RangeError("ByteReader: not a boolean.");
+		return byte === 1;
+	}
+	float64() {
+		if (this.left < 8) throw new RangeError("ByteReader: read past the end.");
+		for (let i = 0; i < 8; i++) scratch.setUint8(i, this.data[this.at++]);
+		return scratch.getFloat64(0, true);
+	}
+	bytes() {
+		const length = this.uint();
+		if (length > this.left) throw new RangeError("ByteReader: read past the end.");
+		const out = this.data.slice(this.at, this.at + length);
+		this.at += length;
+		return out;
+	}
+	string() {
+		const bytes = this.bytes();
+		let out = "";
+		for (let i = 0; i < bytes.length;) {
+			const b = bytes[i++];
+			let c;
+			if (b < 128) c = b;
+			else if (b >= 194 && b < 224) c = (b & 31) << 6 | this.tail(bytes, i++);
+			else if (b >= 224 && b < 240) {
+				c = (b & 15) << 12 | this.tail(bytes, i++) << 6 | this.tail(bytes, i++);
+				if (c < 2048 || c >= 55296 && c <= 57343) throw new RangeError("ByteReader: not UTF-8.");
+			} else if (b >= 240 && b < 245) {
+				c = (b & 7) << 18 | this.tail(bytes, i++) << 12 | this.tail(bytes, i++) << 6 | this.tail(bytes, i++);
+				if (c < 65536 || c > 1114111) throw new RangeError("ByteReader: not UTF-8.");
+			} else throw new RangeError("ByteReader: not UTF-8.");
+			out += String.fromCodePoint(c);
+		}
+		return out;
+	}
+	tail(bytes, i) {
+		const b = bytes[i];
+		if (b === void 0 || (b & 192) !== 128) throw new RangeError("ByteReader: not UTF-8.");
+		return b & 63;
+	}
+};
+//#endregion
+export { ByteWriter as n, ByteReader as t };

package/shared-B_2uj6dc.d.ts

@@ -0,0 +1,70 @@
+//#region src/bytes.d.ts
+/**
+ * Numbers and strings as bytes and back, exactly: what a game sends in a
+ * match, written once and read the same way on every device.
+ *
+ * Integers are varints — a byte for anything under 128 — so a message of small
+ * numbers stays small; floats are their eight bytes, little-endian, so they
+ * arrive with every bit they left with; strings are UTF-8.
+ *
+ * ```ts
+ * const out = new ByteWriter().uint(PICK).uint(fighter).bool(ready).finish();
+ * match.send(out);
+ *
+ * const read = new ByteReader(data);
+ * if (read.uint() === PICK) setPick(from, read.uint(), read.bool());
+ * ```
+ *
+ * @module bytes
+ */
+/**
+ * Builds a message.
+ *
+ * @group Bytes
+ */
+declare class ByteWriter {
+  private buffer;
+  private length;
+  private room;
+  /** One byte, 0..255. */
+  byte(value: number): this;
+  /** A whole number from 0 up to 2⁵³: one byte under 128, two under 16384, and so on. */
+  uint(value: number): this;
+  /** An integer from −2⁵² up to, not including, 2⁵², small ones in a byte whichever their sign. */
+  int(value: number): this;
+  bool(value: boolean): this;
+  /** A number's eight bytes, exactly. */
+  float64(value: number): this;
+  /** Bytes, after their length. */
+  bytes(value: Uint8Array): this;
+  /** A string as UTF-8, after its length in bytes. A lone surrogate is written as U+FFFD. */
+  string(value: string): this;
+  /** What has been written, as a message of its own. */
+  finish(): Uint8Array;
+}
+/**
+ * Reads a message, in the order it was written. Reading past its end, or a
+ * value that is not what it should be, throws a `RangeError`: a message from
+ * another device is checked, not believed.
+ *
+ * @group Bytes
+ */
+declare class ByteReader {
+  private at;
+  private readonly data;
+  constructor(data: Uint8Array);
+  /** Whether everything has been read. */
+  get done(): boolean;
+  /** How many bytes are left. */
+  get left(): number;
+  byte(): number;
+  uint(): number;
+  int(): number;
+  bool(): boolean;
+  float64(): number;
+  bytes(): Uint8Array;
+  string(): string;
+  private tail;
+}
+//#endregion
+export { ByteWriter as n, ByteReader as t };