@loaders.gl/wkt 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/lib/utils/base64-encoder.js

@@ -1,7 +1,153 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/*
+const binary_to_b64_map = [
+  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
+  'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
+  'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a',
+  'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
+  'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
+  't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1',
+  '2', '3', '4', '5', '6', '7', '8', '9', '+',
+  '/', '='
+];
+const b64_to_binary_map = {
+  '0': 52, '1': 53, '2': 54, '3': 55, '4': 56, '5': 57, '6': 58, '7': 59, '8': 60, '9': 61,
+  A: 0, B: 1, C: 2, D: 3, E: 4, F: 5, G: 6, H: 7, I: 8, J: 9, K: 10, L: 11, M: 12, N: 13, O: 14,
+  P: 15, Q: 16, R: 17, S: 18, T: 19, U: 20, V: 21, W: 22, X: 23, Y: 24, Z: 25, a: 26, b: 27,
+  c: 28, d: 29, e: 30, f: 31, g: 32, h: 33, i: 34, j: 35, k: 36, l: 37, m: 38, n: 39, o: 40,
+  p: 41, q: 42, r: 43, s: 44, t: 45, u: 46, v: 47, w: 48, x: 49, y: 50, z: 51, '+': 62, '/': 63,
+  '=': 64
+};
+
+*/
 export class Base64Encoder {
-  getDecodedLength(array) {
-    return Math.ceil(array.byteLength / 4) * 3;
-  }
-  decode(array, target) {}
+    getDecodedLength(array) {
+        return Math.ceil(array.byteLength / 4) * 3;
+    }
+    decode(array, target) { } // eslint-disable-line
 }
-//# sourceMappingURL=base64-encoder.js.map
+/*
+
+//generates an array iterator that returns 3 elements at a time. Use to loop through the Uint8Array Array Buffer
+// to be converted to Base64.  (binary array buffer) 8bits * 3 = 6bits * 4 (base64 representation)
+const generateTripleIterator = (arr) => {
+  return {
+      *[Symbol.iterator]() {
+          for(let n = 0; n < arr.length; n+=3) {
+              let result = [];
+              result.push(arr[n]);
+
+              if(n+1 < arr.length)
+                  result.push(arr[n+1]);
+              if(n+2 < arr.length)
+                  result.push(arr[n+2]);
+
+              yield result;
+          }
+      }
+  };
+};
+
+//generates an array iterator that returns 4 elements at a time.  Use to loop through
+// Base64 string because Base64 string is multiples of 4 characters.
+const generateQuadrupleIterator = (arr) => {
+  return {
+      *[Symbol.iterator]() {
+          for(let n = 0; n < arr.length; n+=4) {
+              yield [...arr.slice(n, n+4)];
+          }
+      }
+  };
+};
+
+// Converts a triple of 8 bits into a quadruple of 6 bits.  use to convert binary to base64 representation
+const tripleConvert = (first, second, third) => {
+  let [] = triple;
+  let binary = null, a = null, b = null, c = null, d = null;
+  if (triple.length === 1) {
+      binary = (first << 4);
+      a = ((binary & 4032) >>> 6);
+      b = (binary & 63);
+      c = 64;
+      d = 64;
+  } else if (triple.length === 2) {
+      binary = ((first << 10) | (second << 2));
+      a = ((binary & 258048) >>> 12);
+      b = ((binary & 4032) >>> 6);
+      c = (binary & 63);
+      d = 64;
+  } else {
+      binary = ((first << 16) | (second << 8) | third);
+      a = ((binary & 16515072) >>> 18);
+      b = ((binary & 258048) >>> 12);
+      c = ((binary & 4032) >>> 6);
+      d = (binary & 63);
+  }
+
+  return [a, b, c, d];
+};
+
+// Converts a quadruple of 6 bits into a triple of 8 bits.  use to convert base64 representation into binary
+const quadrupleConvert = (quadruple) => {
+  let [a, b, c, d] = quadruple;
+  let binary = null, first = null, second = null, third = null;
+
+  if(c === 64 && d === 64) {
+      //two padding
+      binary = ((a << 6) | b);
+      first = (binary >> 4);   //shift off 4 bits, 2 bits per padding
+  } else if(d === 64) {
+      //one padding
+      binary = ((a << 12) | (b << 6) | c );
+      binary = (binary >> 2); //shift off 2 bits
+      first = binary >> 8;
+      second = ((binary << 24) >>> 24);
+  } else {
+      //no padding
+      binary = ((a << 18) | (b << 12) | (c << 6) | d );
+      first = (binary >>> 16);
+      second = ((binary << 16) >>> 24);
+      third = ((binary << 24) >>> 24);
+  }
+
+  return [first, second, third];
+};
+
+// Convert 8Bits Array Buffer to Base64 string
+export const ab2b64 = (buffer) => {
+  const b64strArray = [];
+  const view = new Uint8Array(buffer);
+  let iterator = generateTripleIterator(view);
+  for(let triple of iterator) {
+      b64strArray.push(...tripleConvert(triple));
+  }
+  return b64strArray.map(b64CharCodePoint => binary_to_b64_map[b64CharCodePoint]).join("");
+};
+
+// Convert Base64 String to 8Bits Array Buffer
+export const b642ab = (b64str) => {
+  let buffer_length = (b64str.length / 4) * 3;
+  if(b64str.slice(-2) === '==') {
+      buffer_length -= 2;
+  } else if(b64str.slice(-1) === '=') {
+      buffer_length -= 1;
+  }
+
+  let buffer = new ArrayBuffer(buffer_length);
+  const view = new Uint8Array(buffer);
+  let iterator = generateQuadrupleIterator(b64str.split("").map(b64char => b64_to_binary_map[b64char]));
+  let byteIndex = 0;
+  for(let quadruple of iterator) {
+      quadrupleConvert(quadruple).forEach(byte => {
+          if(byte != null) {
+              view[byteIndex] = byte;
+              byteIndex++;
+          }
+      });
+  }
+  return buffer;
+};
+
+*/

package/dist/lib/utils/binary-reader.js

@@ -1,66 +1,69 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** A DataView that tracks byte offset when reading. */
 export class BinaryReader {
-  constructor(arrayBuffer) {
-    let isBigEndian = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    this.arrayBuffer = void 0;
-    this.dataView = void 0;
-    this.byteOffset = void 0;
-    this.littleEndian = void 0;
-    this.arrayBuffer = arrayBuffer;
-    this.dataView = new DataView(arrayBuffer);
-    this.byteOffset = 0;
-    this.littleEndian = !isBigEndian;
-  }
-  readUInt8() {
-    const value = this.dataView.getUint8(this.byteOffset);
-    this.byteOffset += 1;
-    return value;
-  }
-  readUInt16() {
-    const value = this.dataView.getUint16(this.byteOffset, this.littleEndian);
-    this.byteOffset += 2;
-    return value;
-  }
-  readUInt32() {
-    const value = this.dataView.getUint32(this.byteOffset, this.littleEndian);
-    this.byteOffset += 4;
-    return value;
-  }
-  readInt8() {
-    const value = this.dataView.getInt8(this.byteOffset);
-    this.byteOffset += 1;
-    return value;
-  }
-  readInt16() {
-    const value = this.dataView.getInt16(this.byteOffset, this.littleEndian);
-    this.byteOffset += 2;
-    return value;
-  }
-  readInt32() {
-    const value = this.dataView.getInt32(this.byteOffset, this.littleEndian);
-    this.byteOffset += 4;
-    return value;
-  }
-  readFloat() {
-    const value = this.dataView.getFloat32(this.byteOffset, this.littleEndian);
-    this.byteOffset += 4;
-    return value;
-  }
-  readDouble() {
-    const value = this.dataView.getFloat64(this.byteOffset, this.littleEndian);
-    this.byteOffset += 8;
-    return value;
-  }
-  readVarInt() {
-    let result = 0;
-    let bytesRead = 0;
-    let nextByte;
-    do {
-      nextByte = this.dataView.getUint8(this.byteOffset + bytesRead);
-      result += (nextByte & 0x7f) << 7 * bytesRead;
-      bytesRead++;
-    } while (nextByte >= 0x80);
-    this.byteOffset += bytesRead;
-    return result;
-  }
+    arrayBuffer;
+    dataView;
+    byteOffset;
+    littleEndian;
+    constructor(arrayBuffer, isBigEndian = false) {
+        this.arrayBuffer = arrayBuffer;
+        this.dataView = new DataView(arrayBuffer);
+        this.byteOffset = 0;
+        this.littleEndian = !isBigEndian;
+    }
+    readUInt8() {
+        const value = this.dataView.getUint8(this.byteOffset);
+        this.byteOffset += 1;
+        return value;
+    }
+    readUInt16() {
+        const value = this.dataView.getUint16(this.byteOffset, this.littleEndian);
+        this.byteOffset += 2;
+        return value;
+    }
+    readUInt32() {
+        const value = this.dataView.getUint32(this.byteOffset, this.littleEndian);
+        this.byteOffset += 4;
+        return value;
+    }
+    readInt8() {
+        const value = this.dataView.getInt8(this.byteOffset);
+        this.byteOffset += 1;
+        return value;
+    }
+    readInt16() {
+        const value = this.dataView.getInt16(this.byteOffset, this.littleEndian);
+        this.byteOffset += 2;
+        return value;
+    }
+    readInt32() {
+        const value = this.dataView.getInt32(this.byteOffset, this.littleEndian);
+        this.byteOffset += 4;
+        return value;
+    }
+    readFloat() {
+        const value = this.dataView.getFloat32(this.byteOffset, this.littleEndian);
+        this.byteOffset += 4;
+        return value;
+    }
+    readDouble() {
+        const value = this.dataView.getFloat64(this.byteOffset, this.littleEndian);
+        this.byteOffset += 8;
+        return value;
+    }
+    readVarInt() {
+        let result = 0;
+        let bytesRead = 0;
+        let nextByte;
+        do {
+            // TODO - this needs to be accessed via data view?
+            nextByte = this.dataView.getUint8(this.byteOffset + bytesRead);
+            result += (nextByte & 0x7f) << (7 * bytesRead);
+            bytesRead++;
+        } while (nextByte >= 0x80);
+        this.byteOffset += bytesRead;
+        return result;
+    }
 }
-//# sourceMappingURL=binary-reader.js.map

package/dist/lib/utils/binary-writer.js

@@ -1,113 +1,121 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/cschwarz/wkx under MIT license, Copyright (c) 2013 Christian Schwarz
 const LE = true;
 const BE = false;
 export class BinaryWriter {
-  constructor(size, allowResize) {
-    this.arrayBuffer = void 0;
-    this.dataView = void 0;
-    this.byteOffset = 0;
-    this.allowResize = false;
-    this.arrayBuffer = new ArrayBuffer(size);
-    this.dataView = new DataView(this.arrayBuffer);
-    this.byteOffset = 0;
-    this.allowResize = allowResize || false;
-  }
-  writeUInt8(value) {
-    this._ensureSize(1);
-    this.dataView.setUint8(this.byteOffset, value);
-    this.byteOffset += 1;
-  }
-  writeUInt16LE(value) {
-    this._ensureSize(2);
-    this.dataView.setUint16(this.byteOffset, value, LE);
-    this.byteOffset += 2;
-  }
-  writeUInt16BE(value) {
-    this._ensureSize(2);
-    this.dataView.setUint16(this.byteOffset, value, BE);
-    this.byteOffset += 2;
-  }
-  writeUInt32LE(value) {
-    this._ensureSize(4);
-    this.dataView.setUint32(this.byteOffset, value, LE);
-    this.byteOffset += 4;
-  }
-  writeUInt32BE(value) {
-    this._ensureSize(4);
-    this.dataView.setUint32(this.byteOffset, value, BE);
-    this.byteOffset += 4;
-  }
-  writeInt8(value) {
-    this._ensureSize(1);
-    this.dataView.setInt8(this.byteOffset, value);
-    this.byteOffset += 1;
-  }
-  writeInt16LE(value) {
-    this._ensureSize(2);
-    this.dataView.setInt16(this.byteOffset, value, LE);
-    this.byteOffset += 2;
-  }
-  writeInt16BE(value) {
-    this._ensureSize(2);
-    this.dataView.setInt16(this.byteOffset, value, BE);
-    this.byteOffset += 2;
-  }
-  writeInt32LE(value) {
-    this._ensureSize(4);
-    this.dataView.setInt32(this.byteOffset, value, LE);
-    this.byteOffset += 4;
-  }
-  writeInt32BE(value) {
-    this._ensureSize(4);
-    this.dataView.setInt32(this.byteOffset, value, BE);
-    this.byteOffset += 4;
-  }
-  writeFloatLE(value) {
-    this._ensureSize(4);
-    this.dataView.setFloat32(this.byteOffset, value, LE);
-    this.byteOffset += 4;
-  }
-  writeFloatBE(value) {
-    this._ensureSize(4);
-    this.dataView.setFloat32(this.byteOffset, value, BE);
-    this.byteOffset += 4;
-  }
-  writeDoubleLE(value) {
-    this._ensureSize(8);
-    this.dataView.setFloat64(this.byteOffset, value, LE);
-    this.byteOffset += 8;
-  }
-  writeDoubleBE(value) {
-    this._ensureSize(8);
-    this.dataView.setFloat64(this.byteOffset, value, BE);
-    this.byteOffset += 8;
-  }
-  writeVarInt(value) {
-    let length = 1;
-    while ((value & 0xffffff80) !== 0) {
-      this.writeUInt8(value & 0x7f | 0x80);
-      value >>>= 7;
-      length++;
-    }
-    this.writeUInt8(value & 0x7f);
-    return length;
-  }
-  writeBuffer(arrayBuffer) {
-    this._ensureSize(arrayBuffer.byteLength);
-    const tempArray = new Uint8Array(this.arrayBuffer);
-    tempArray.set(new Uint8Array(arrayBuffer), this.byteOffset);
-    this.byteOffset += arrayBuffer.byteLength;
-  }
-  _ensureSize(size) {
-    if (this.arrayBuffer.byteLength < this.byteOffset + size) {
-      if (this.allowResize) {
-        const newArrayBuffer = new ArrayBuffer(this.byteOffset + size);
-        const tempArray = new Uint8Array(newArrayBuffer);
-        tempArray.set(new Uint8Array(this.arrayBuffer));
-        this.arrayBuffer = newArrayBuffer;
-      } else {
-        throw new Error('BinaryWriter overflow');
-      }
-    }
-  }
+    arrayBuffer;
+    dataView;
+    byteOffset = 0;
+    allowResize = false;
+    constructor(size, allowResize) {
+        this.arrayBuffer = new ArrayBuffer(size);
+        this.dataView = new DataView(this.arrayBuffer);
+        this.byteOffset = 0;
+        this.allowResize = allowResize || false;
+    }
+    writeUInt8(value) {
+        this._ensureSize(1);
+        this.dataView.setUint8(this.byteOffset, value);
+        this.byteOffset += 1;
+    }
+    writeUInt16LE(value) {
+        this._ensureSize(2);
+        this.dataView.setUint16(this.byteOffset, value, LE);
+        this.byteOffset += 2;
+    }
+    writeUInt16BE(value) {
+        this._ensureSize(2);
+        this.dataView.setUint16(this.byteOffset, value, BE);
+        this.byteOffset += 2;
+    }
+    writeUInt32LE(value) {
+        this._ensureSize(4);
+        this.dataView.setUint32(this.byteOffset, value, LE);
+        this.byteOffset += 4;
+    }
+    writeUInt32BE(value) {
+        this._ensureSize(4);
+        this.dataView.setUint32(this.byteOffset, value, BE);
+        this.byteOffset += 4;
+    }
+    writeInt8(value) {
+        this._ensureSize(1);
+        this.dataView.setInt8(this.byteOffset, value);
+        this.byteOffset += 1;
+    }
+    writeInt16LE(value) {
+        this._ensureSize(2);
+        this.dataView.setInt16(this.byteOffset, value, LE);
+        this.byteOffset += 2;
+    }
+    writeInt16BE(value) {
+        this._ensureSize(2);
+        this.dataView.setInt16(this.byteOffset, value, BE);
+        this.byteOffset += 2;
+    }
+    writeInt32LE(value) {
+        this._ensureSize(4);
+        this.dataView.setInt32(this.byteOffset, value, LE);
+        this.byteOffset += 4;
+    }
+    writeInt32BE(value) {
+        this._ensureSize(4);
+        this.dataView.setInt32(this.byteOffset, value, BE);
+        this.byteOffset += 4;
+    }
+    writeFloatLE(value) {
+        this._ensureSize(4);
+        this.dataView.setFloat32(this.byteOffset, value, LE);
+        this.byteOffset += 4;
+    }
+    writeFloatBE(value) {
+        this._ensureSize(4);
+        this.dataView.setFloat32(this.byteOffset, value, BE);
+        this.byteOffset += 4;
+    }
+    writeDoubleLE(value) {
+        this._ensureSize(8);
+        this.dataView.setFloat64(this.byteOffset, value, LE);
+        this.byteOffset += 8;
+    }
+    writeDoubleBE(value) {
+        this._ensureSize(8);
+        this.dataView.setFloat64(this.byteOffset, value, BE);
+        this.byteOffset += 8;
+    }
+    /** A varint uses a variable number of bytes */
+    writeVarInt(value) {
+        // TODO - ensure size?
+        let length = 1;
+        while ((value & 0xffffff80) !== 0) {
+            this.writeUInt8((value & 0x7f) | 0x80);
+            value >>>= 7;
+            length++;
+        }
+        this.writeUInt8(value & 0x7f);
+        return length;
+    }
+    /** Append another ArrayBuffer to this ArrayBuffer */
+    writeBuffer(arrayBuffer) {
+        this._ensureSize(arrayBuffer.byteLength);
+        const tempArray = new Uint8Array(this.arrayBuffer);
+        tempArray.set(new Uint8Array(arrayBuffer), this.byteOffset);
+        this.byteOffset += arrayBuffer.byteLength;
+    }
+    /** Resizes this.arrayBuffer if not enough space */
+    _ensureSize(size) {
+        if (this.arrayBuffer.byteLength < this.byteOffset + size) {
+            if (this.allowResize) {
+                const newArrayBuffer = new ArrayBuffer(this.byteOffset + size);
+                const tempArray = new Uint8Array(newArrayBuffer);
+                tempArray.set(new Uint8Array(this.arrayBuffer));
+                this.arrayBuffer = newArrayBuffer;
+            }
+            else {
+                throw new Error('BinaryWriter overflow');
+            }
+        }
+    }
 }
-//# sourceMappingURL=binary-writer.js.map

package/dist/lib/utils/hex-encoder.js

@@ -1,40 +1,54 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * Simple helper to decode and encode "hex encoded" binary buffers
+ * without first converting to string.
+ */
 export class HexEncoder {
-  getEncodedLength(array) {
-    return array.byteLength * 2;
-  }
-  getDecodedLength(array) {
-    return Math.ceil(array.byteLength / 2);
-  }
-  decode(array, result) {
-    for (let i = 0; i < array.byteLength / 2; ++i) {
-      const halfByte1 = hexDecode(array[i]);
-      const halfByte2 = hexDecode(array[i + 1]);
-      result[i] = halfByte1 * 16 + halfByte2;
+    /** Get length in bytes required to store encoded data */
+    getEncodedLength(array) {
+        return array.byteLength * 2;
     }
-    return result;
-  }
-  encode(array, result) {
-    for (let i = 0; i < array.byteLength; ++i) {
-      const byte = array[i];
-      result[i * 2] = hexEncode(byte & 0x0f);
-      result[i * 2 + 1] = hexEncode(byte & 0xf0);
+    /** Get length in bytes required to store decoded data */
+    getDecodedLength(array) {
+        return Math.ceil(array.byteLength / 2);
+    }
+    /** Decode hexadecimal */
+    decode(array, result) {
+        for (let i = 0; i < array.byteLength / 2; ++i) {
+            const halfByte1 = hexDecode(array[i]);
+            const halfByte2 = hexDecode(array[i + 1]);
+            result[i] = halfByte1 * 16 + halfByte2;
+        }
+        // Check if final half byte (is that legal?)
+        // if (array.byteLength % 2) {
+        //   const halfByte1 = hexDecode(array[i]);
+        // }
+        return result;
+    }
+    /** Encode hexadecimal */
+    encode(array, result) {
+        for (let i = 0; i < array.byteLength; ++i) {
+            const byte = array[i];
+            result[i * 2] = hexEncode(byte & 0x0f);
+            result[i * 2 + 1] = hexEncode(byte & 0xf0);
+        }
+        return result;
     }
-    return result;
-  }
 }
 function hexEncode(value) {
-  if (value < 10) {
-    return value + 48;
-  }
-  return value - 10 + 65;
+    if (value < 10) {
+        return value + 48; // ASCII of 0
+    }
+    return value - 10 + 65; // ASCII of capital A
 }
 function hexDecode(value) {
-  if (value >= 65) {
-    return value - 65 + 10;
-  }
-  if (value >= 97) {
-    return value - 97 + 10;
-  }
-  return value - 48;
+    if (value >= 65) {
+        return value - 65 + 10; // ASCII of A
+    }
+    if (value >= 97) {
+        return value - 97 + 10; // ASCII of a
+    }
+    return value - 48; // ASCII of 0
 }
-//# sourceMappingURL=hex-encoder.js.map