@woosh/meep-engine 2.123.0 → 2.123.2

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.123.0",
+  "version": "2.123.2",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/binary/base58/base58_encode.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Using bitcoin-inspired base58 encoding
+ * Primarily intended for UUID compression
+ * @param {Uint8Array} source
+ * @param {number} offset
+ * @param {number} byte_count
+ * @returns {string}
+ */
+export function base58_encode(source: Uint8Array, offset: number, byte_count: number): string;
+//# sourceMappingURL=base58_encode.d.ts.map

package/src/core/binary/base58/base58_encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base58_encode.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/base58/base58_encode.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,sCALW,UAAU,UACV,MAAM,cACN,MAAM,GACJ,MAAM,CA0ElB"}

package/src/core/binary/base58/base58_encode.js

@@ -0,0 +1,87 @@
+import { assert } from "../../assert.js";
+
+const base58_alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+const scratch = new Uint8Array(256);
+
+/**
+ * Using bitcoin-inspired base58 encoding
+ * Primarily intended for UUID compression
+ * @param {Uint8Array} source
+ * @param {number} offset
+ * @param {number} byte_count
+ * @returns {string}
+ */
+export function base58_encode(
+    source,
+    offset,
+    byte_count
+) {
+
+    // ported from the bitcoin's C codebase: https://github.com/bitcoin/bitcoin/blob/08a7316c144f9f2516db8fa62400893f4358c5ae/src/base58.cpp#L71
+
+    if (byte_count === 0) {
+        return "";
+    }
+
+    // Skip & count leading zeroes.
+    let zeroes = 0
+    let length = 0
+    let pbegin = offset
+    const pend = offset + byte_count
+
+    while (pbegin !== pend && source[pbegin] === 0) {
+        pbegin++
+        zeroes++
+    }
+
+    // Allocate enough space in big-endian base58 representation.
+    const size = ((pend - pbegin) * 138 / 100 + 1) >>> 0; /// log(256) / log(58), rounded up.
+
+    // use scratch if possible to avoid allocation
+    const b58 = (size <= scratch.length) ? scratch : new Uint8Array(size);
+
+    // Process the bytes.
+    while (pbegin !== pend) {
+        let carry = source[pbegin]
+
+        // Apply "b58 = b58 * 256 + ch".
+        let i = 0
+
+        for (
+            let it1 = size - 1;
+             (carry !== 0 || i < length) && (it1 !== -1);
+             it1--, i++
+        ) {
+
+            carry += (256 * b58[it1]) >>> 0;
+            b58[it1] = (carry % 58) >>> 0;
+            carry = (carry / 58) >>> 0;
+
+        }
+
+        assert.equal(carry, 0, 'carry must be zero');
+
+        length = i;
+        pbegin++;
+    }
+
+    // Skip leading zeroes in base58 result.
+    let it2 = size - length
+    while (it2 !== size && b58[it2] === 0) {
+        it2++
+    }
+
+    // Translate the result into a string.
+    let str = base58_alphabet.charAt(0).repeat(zeroes)
+    for (; it2 < size; ++it2) {
+        str += base58_alphabet.charAt(b58[it2])
+    }
+
+    if (b58 === scratch) {
+        // clear out scratch
+        scratch.fill(0);
+    }
+
+    return str;
+}

package/src/engine/ecs/guid/UUID.d.ts

@@ -1,7 +1,7 @@
 /**
  * Universally Unique Identifier
+ * The default is Nil UUID, where all bits are set to 0
  * @see IETF RFC 4122
- *
  */
 export class UUID {
     /**
@@ -10,13 +10,13 @@ export class UUID {
      */
     static v1(): UUID;
     /**
-     *
+     * Variant 4 UUID generator (fully random)
      * @returns {UUID}
      */
     static v4(): UUID;
     /**
      * Shortcut to generate string-form ID
-     * Uses v4 UUID
+     * Uses v4(random) UUID
      * @return {string}
      */
     static string(): string;
@@ -46,13 +46,15 @@ export class UUID {
      */
     v4(): void;
     /***
-     * String in UUID format
-     * @see https://github.com/uuidjs/uuid/blob/8f028c4ea42ce41a9a9dc5fa634abe525b2e2066/src/parse.js#L3
-     * @param {string} string
+     * Parses standard UUID string of form AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE
+     * @param {string} string String in UUID format
      */
     parse(string: string): void;
     /**
-     * @see https://github.com/uuidjs/uuid/blob/8f028c4ea42ce41a9a9dc5fa634abe525b2e2066/src/stringify.js#L16
+     * Standard UUID string in from: AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE
+     * Result is compatible with the {@link UUID.parse} method.
+     * @example
+     *   a88bb73a-c89f-11ed-afa1-0242ac120002
      * @returns {string}
      */
     toString(): string;
@@ -68,11 +70,18 @@ export class UUID {
      */
     equals(other: UUID): boolean;
     /**
-     * @returns {number}
+     * Compute hash sum
+     * @returns {number} 32bit integer value
      */
     hash(): number;
-    toJSON(): string;
-    fromJSON(v: any): void;
+    /**
+     * @readonly
+     */
+    readonly toJSON: () => string;
+    /**
+     * @readonly
+     */
+    readonly fromJSON: (string: string) => void;
     /**
      * @readonly
      * @type {boolean}

package/src/engine/ecs/guid/UUID.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UUID.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/guid/UUID.js"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH;IAiHI;;;OAGG;IACH,aAFY,IAAI,CAQf;IAED;;;OAGG;IACH,aAFa,IAAI,CAQhB;IAED;;;;OAIG;IACH,iBAFY,MAAM,CAIjB;IA0CD;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,CAQf;IAlMD;;;OAGG;IACH,gBAFW,MAAM,EAAE,GAAC,UAAU,GAAC,SAAS,CAAC,MAAM,CAAC,EAO/C;IAED;;;OAGG;IACH,YAFa,UAAU,CAItB;IAED;;;OAGG;IACH,WAsEC;IAED;;OAEG;IACH,WAUC;IAmCD;;;;OAIG;IACH,cAFW,MAAM,QAmChB;IAeD;;;OAGG;IACH,YAFa,MAAM,CA2BlB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAanB;IAED;;OAEG;IACH,QAFa,MAAM,CAWlB;IAED,iBAEC;IAED,uBAEC;IASL;;;OAGG;IACH,iBAFU,OAAO,CAEI;;CAZpB;;kBAIS,MAAM"}
+{"version":3,"file":"UUID.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/guid/UUID.js"],"names":[],"mappings":"AAyBA;;;;GAIG;AACH;IAiHI;;;OAGG;IACH,aAFY,IAAI,CAQf;IAED;;;OAGG;IACH,aAFa,IAAI,CAQhB;IAED;;;;OAIG;IACH,iBAFY,MAAM,CAIjB;IAyCD;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,CAQf;IAjMD;;;OAGG;IACH,gBAFW,MAAM,EAAE,GAAC,UAAU,GAAC,SAAS,CAAC,MAAM,CAAC,EAO/C;IAED;;;OAGG;IACH,YAFa,UAAU,CAItB;IAED;;;OAGG;IACH,WAsEC;IAED;;OAEG;IACH,WAUC;IAmCD;;;OAGG;IACH,cAFW,MAAM,QAmChB;IAeD;;;;;;OAMG;IACH,YAFa,MAAM,CA2BlB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAcnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAYlB;IAIL;;OAEG;IACH,uBA7EiB,MAAM,CA6EF;IAErB;;OAEG;IACH,4BAzIe,MAAM,UAyIE;IAQvB;;;OAGG;IACH,iBAFU,OAAO,CAEI;;CAtBpB;;kBAcS,MAAM"}

package/src/engine/ecs/guid/UUID.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { dec2hex } from "../../../core/binary/dec2hex.js";
+import { hex2dec } from "../../../core/binary/hex2dec.js";
 import { array_copy } from "../../../core/collection/array/array_copy.js";
 import { randomBytes } from "../../../core/math/random/randomBytes.js";
 import { randomUint8 } from "../../../core/math/random/randomUint8.js";
@@ -24,8 +25,8 @@ let _clockseq = ((randomUint8(random) << 8) | randomUint8(random)) & 0x3fff;
 
 /**
  * Universally Unique Identifier
+ * The default is Nil UUID, where all bits are set to 0
  * @see IETF RFC 4122
- *
  */
 export class UUID {
     #data = new Uint8Array(16);
@@ -153,7 +154,7 @@ export class UUID {
     }
 
     /**
-     *
+     * Variant 4 UUID generator (fully random)
      * @returns {UUID}
      */
     static v4() {
@@ -166,7 +167,7 @@ export class UUID {
 
     /**
      * Shortcut to generate string-form ID
-     * Uses v4 UUID
+     * Uses v4(random) UUID
      * @return {string}
      */
     static string() {
@@ -174,9 +175,8 @@ export class UUID {
     }
 
     /***
-     * String in UUID format
-     * @see https://github.com/uuidjs/uuid/blob/8f028c4ea42ce41a9a9dc5fa634abe525b2e2066/src/parse.js#L3
-     * @param {string} string
+     * Parses standard UUID string of form AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE
+     * @param {string} string String in UUID format
      */
     parse(string) {
         assert.isString(string, 'string');
@@ -186,26 +186,26 @@ export class UUID {
         const arr = this.#data;
 
         // Parse ########-....-....-....-............
-        arr[0] = (v = parseInt(string.slice(0, 8), 16)) >>> 24;
+        arr[0] = (v = hex2dec(string.slice(0, 8))) >>> 24;
         arr[1] = (v >>> 16) & 0xff;
         arr[2] = (v >>> 8) & 0xff;
         arr[3] = v & 0xff;
 
         // Parse ........-####-....-....-............
-        arr[4] = (v = parseInt(string.slice(9, 13), 16)) >>> 8;
+        arr[4] = (v = hex2dec(string.slice(9, 13))) >>> 8;
         arr[5] = v & 0xff;
 
         // Parse ........-....-####-....-............
-        arr[6] = (v = parseInt(string.slice(14, 18), 16)) >>> 8;
+        arr[6] = (v = hex2dec(string.slice(14, 18))) >>> 8;
         arr[7] = v & 0xff;
 
         // Parse ........-....-....-####-............
-        arr[8] = (v = parseInt(string.slice(19, 23), 16)) >>> 8;
+        arr[8] = (v = hex2dec(string.slice(19, 23))) >>> 8;
         arr[9] = v & 0xff;
 
         // Parse ........-....-....-....-############
         // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
-        arr[10] = ((v = parseInt(string.slice(24, 36), 16)) / 0x10000000000) & 0xff;
+        arr[10] = ((v = hex2dec(string.slice(24, 36))) / 0x10000000000) & 0xff;
         arr[11] = (v / 0x100000000) & 0xff;
         arr[12] = (v >>> 24) & 0xff;
         arr[13] = (v >>> 16) & 0xff;
@@ -227,7 +227,10 @@ export class UUID {
     }
 
     /**
-     * @see https://github.com/uuidjs/uuid/blob/8f028c4ea42ce41a9a9dc5fa634abe525b2e2066/src/stringify.js#L16
+     * Standard UUID string in from: AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE
+     * Result is compatible with the {@link UUID.parse} method.
+     * @example
+     *   a88bb73a-c89f-11ed-afa1-0242ac120002
      * @returns {string}
      */
     toString() {
@@ -271,6 +274,7 @@ export class UUID {
      * @returns {boolean}
      */
     equals(other) {
+
         const this_data = this.#data;
         const other_data = other.#data;
 
@@ -284,12 +288,14 @@ export class UUID {
     }
 
     /**
-     * @returns {number}
+     * Compute hash sum
+     * @returns {number} 32bit integer value
      */
     hash() {
         const data = this.#data;
 
-        // use some non-metadata bytes as a hash
+        // use some non-metadata bytes as a hash, favoring speed as this is expected to be used a lot
+
         return data[3] // low byte of "time_low", very likely to differ between two UUIDs
             | data[5] << 8 // low byte of "time_mid"
             | data[9] << 16 // "clock_seq_low"
@@ -297,15 +303,18 @@ export class UUID {
             ;
     }
 
-    toJSON() {
-        return this.toString();
-    }
-
-    fromJSON(v) {
-        this.parse(v);
-    }
 }
 
+/**
+ * @readonly
+ */
+UUID.prototype.toJSON = UUID.prototype.toString;
+
+/**
+ * @readonly
+ */
+UUID.prototype.fromJSON = UUID.prototype.parse;
+
 /**
  * @readonly
  * @type {string}