@loaders.gl/wkt 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/lib/parse-wkt.js

@@ -1,198 +1,227 @@
+"use strict";
+// Fork of https://github.com/mapbox/wellknown under ISC license (MIT/BSD-2-clause equivalent)
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable */
+// @ts-nocheck
 const numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
+// Matches sequences like '100 100' or '100 100 100'.
 const tuples = new RegExp('^' + numberRegexp.source + '(\\s' + numberRegexp.source + '){1,}');
-export default function parseWKT(input) {
-  const parts = input.split(';');
-
-  let _ = parts.pop();
-
-  const srid = (parts.shift() || '').split('=').pop();
-  let i = 0;
-
-  function $(re) {
-    const match = _.substring(i).match(re);
-
-    if (!match) return null;else {
-      i += match[0].length;
-      return match[0];
+/**
+ * Parse WKT and return GeoJSON.
+ *
+ * @param {string} _ A WKT geometry
+ * @return {?Object} A GeoJSON geometry object
+ **/
+function parseWKT(input) {
+    const parts = input.split(';');
+    let _ = parts.pop();
+    const srid = (parts.shift() || '').split('=').pop();
+    let i = 0;
+    function $(re) {
+        const match = _.substring(i).match(re);
+        if (!match)
+            return null;
+        else {
+            i += match[0].length;
+            return match[0];
+        }
+    }
+    function crs(obj) {
+        if (obj && srid.match(/\d+/)) {
+            obj.crs = {
+                type: 'name',
+                properties: {
+                    name: 'urn:ogc:def:crs:EPSG::' + srid
+                }
+            };
+        }
+        return obj;
+    }
+    function white() {
+        $(/^\s*/);
+    }
+    function multicoords() {
+        white();
+        let depth = 0;
+        const rings = [];
+        const stack = [rings];
+        let pointer = rings;
+        let elem;
+        while ((elem = $(/^(\()/) || $(/^(\))/) || $(/^(,)/) || $(tuples))) {
+            if (elem === '(') {
+                stack.push(pointer);
+                pointer = [];
+                stack[stack.length - 1].push(pointer);
+                depth++;
+            }
+            else if (elem === ')') {
+                // For the case: Polygon(), ...
+                if (pointer.length === 0)
+                    return null;
+                // @ts-ignore
+                pointer = stack.pop();
+                // the stack was empty, input was malformed
+                if (!pointer)
+                    return null;
+                depth--;
+                if (depth === 0)
+                    break;
+            }
+            else if (elem === ',') {
+                pointer = [];
+                stack[stack.length - 1].push(pointer);
+            }
+            else if (!elem.split(/\s/g).some(isNaN)) {
+                Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
+            }
+            else {
+                return null;
+            }
+            white();
+        }
+        if (depth !== 0)
+            return null;
+        return rings;
     }
-  }
-
-  function crs(obj) {
-    if (obj && srid.match(/\d+/)) {
-      obj.crs = {
-        type: 'name',
-        properties: {
-          name: 'urn:ogc:def:crs:EPSG::' + srid
+    function coords() {
+        const list = [];
+        let item;
+        let pt;
+        while ((pt = $(tuples) || $(/^(,)/))) {
+            if (pt === ',') {
+                list.push(item);
+                item = [];
+            }
+            else if (!pt.split(/\s/g).some(isNaN)) {
+                if (!item)
+                    item = [];
+                Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
+            }
+            white();
         }
-      };
+        if (item)
+            list.push(item);
+        else
+            return null;
+        return list.length ? list : null;
     }
-
-    return obj;
-  }
-
-  function white() {
-    $(/^\s*/);
-  }
-
-  function multicoords() {
-    white();
-    let depth = 0;
-    const rings = [];
-    const stack = [rings];
-    let pointer = rings;
-    let elem;
-
-    while (elem = $(/^(\()/) || $(/^(\))/) || $(/^(,)/) || $(tuples)) {
-      if (elem === '(') {
-        stack.push(pointer);
-        pointer = [];
-        stack[stack.length - 1].push(pointer);
-        depth++;
-      } else if (elem === ')') {
-        if (pointer.length === 0) return null;
-        pointer = stack.pop();
-        if (!pointer) return null;
-        depth--;
-        if (depth === 0) break;
-      } else if (elem === ',') {
-        pointer = [];
-        stack[stack.length - 1].push(pointer);
-      } else if (!elem.split(/\s/g).some(isNaN)) {
-        Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
-      } else {
-        return null;
-      }
-
-      white();
+    function point() {
+        if (!$(/^(point(\sz)?)/i))
+            return null;
+        white();
+        if (!$(/^(\()/))
+            return null;
+        const c = coords();
+        if (!c)
+            return null;
+        white();
+        if (!$(/^(\))/))
+            return null;
+        return {
+            type: 'Point',
+            coordinates: c[0]
+        };
     }
-
-    if (depth !== 0) return null;
-    return rings;
-  }
-
-  function coords() {
-    const list = [];
-    let item;
-    let pt;
-
-    while (pt = $(tuples) || $(/^(,)/)) {
-      if (pt === ',') {
-        list.push(item);
-        item = [];
-      } else if (!pt.split(/\s/g).some(isNaN)) {
-        if (!item) item = [];
-        Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
-      }
-
-      white();
+    function multipoint() {
+        if (!$(/^(multipoint)/i))
+            return null;
+        white();
+        const newCoordsFormat = _.substring(_.indexOf('(') + 1, _.length - 1)
+            .replace(/\(/g, '')
+            .replace(/\)/g, '');
+        _ = 'MULTIPOINT (' + newCoordsFormat + ')';
+        const c = multicoords();
+        if (!c)
+            return null;
+        white();
+        return {
+            type: 'MultiPoint',
+            coordinates: c
+        };
+    }
+    function multilinestring() {
+        if (!$(/^(multilinestring)/i))
+            return null;
+        white();
+        const c = multicoords();
+        if (!c)
+            return null;
+        white();
+        return {
+            type: 'MultiLineString',
+            coordinates: c
+        };
+    }
+    function linestring() {
+        if (!$(/^(linestring(\sz)?)/i))
+            return null;
+        white();
+        if (!$(/^(\()/))
+            return null;
+        const c = coords();
+        if (!c)
+            return null;
+        if (!$(/^(\))/))
+            return null;
+        return {
+            type: 'LineString',
+            coordinates: c
+        };
+    }
+    function polygon() {
+        if (!$(/^(polygon(\sz)?)/i))
+            return null;
+        white();
+        const c = multicoords();
+        if (!c)
+            return null;
+        return {
+            type: 'Polygon',
+            coordinates: c
+        };
+    }
+    function multipolygon() {
+        if (!$(/^(multipolygon)/i))
+            return null;
+        white();
+        const c = multicoords();
+        if (!c)
+            return null;
+        return {
+            type: 'MultiPolygon',
+            coordinates: c
+        };
+    }
+    function geometrycollection() {
+        const geometries = [];
+        let geometry;
+        if (!$(/^(geometrycollection)/i))
+            return null;
+        white();
+        if (!$(/^(\()/))
+            return null;
+        while ((geometry = root())) {
+            geometries.push(geometry);
+            white();
+            $(/^(,)/);
+            white();
+        }
+        if (!$(/^(\))/))
+            return null;
+        return {
+            type: 'GeometryCollection',
+            geometries: geometries
+        };
     }
-
-    if (item) list.push(item);else return null;
-    return list.length ? list : null;
-  }
-
-  function point() {
-    if (!$(/^(point(\sz)?)/i)) return null;
-    white();
-    if (!$(/^(\()/)) return null;
-    const c = coords();
-    if (!c) return null;
-    white();
-    if (!$(/^(\))/)) return null;
-    return {
-      type: 'Point',
-      coordinates: c[0]
-    };
-  }
-
-  function multipoint() {
-    if (!$(/^(multipoint)/i)) return null;
-    white();
-
-    const newCoordsFormat = _.substring(_.indexOf('(') + 1, _.length - 1).replace(/\(/g, '').replace(/\)/g, '');
-
-    _ = 'MULTIPOINT (' + newCoordsFormat + ')';
-    const c = multicoords();
-    if (!c) return null;
-    white();
-    return {
-      type: 'MultiPoint',
-      coordinates: c
-    };
-  }
-
-  function multilinestring() {
-    if (!$(/^(multilinestring)/i)) return null;
-    white();
-    const c = multicoords();
-    if (!c) return null;
-    white();
-    return {
-      type: 'MultiLineString',
-      coordinates: c
-    };
-  }
-
-  function linestring() {
-    if (!$(/^(linestring(\sz)?)/i)) return null;
-    white();
-    if (!$(/^(\()/)) return null;
-    const c = coords();
-    if (!c) return null;
-    if (!$(/^(\))/)) return null;
-    return {
-      type: 'LineString',
-      coordinates: c
-    };
-  }
-
-  function polygon() {
-    if (!$(/^(polygon(\sz)?)/i)) return null;
-    white();
-    const c = multicoords();
-    if (!c) return null;
-    return {
-      type: 'Polygon',
-      coordinates: c
-    };
-  }
-
-  function multipolygon() {
-    if (!$(/^(multipolygon)/i)) return null;
-    white();
-    const c = multicoords();
-    if (!c) return null;
-    return {
-      type: 'MultiPolygon',
-      coordinates: c
-    };
-  }
-
-  function geometrycollection() {
-    const geometries = [];
-    let geometry;
-    if (!$(/^(geometrycollection)/i)) return null;
-    white();
-    if (!$(/^(\()/)) return null;
-
-    while (geometry = root()) {
-      geometries.push(geometry);
-      white();
-      $(/^(,)/);
-      white();
+    function root() {
+        return (point() ||
+            linestring() ||
+            polygon() ||
+            multipoint() ||
+            multilinestring() ||
+            multipolygon() ||
+            geometrycollection());
     }
-
-    if (!$(/^(\))/)) return null;
-    return {
-      type: 'GeometryCollection',
-      geometries: geometries
-    };
-  }
-
-  function root() {
-    return point() || linestring() || polygon() || multipoint() || multilinestring() || multipolygon() || geometrycollection();
-  }
-
-  return crs(root());
+    return crs(root());
 }
-//# sourceMappingURL=parse-wkt.js.map
+exports.default = parseWKT;

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

@@ -1,153 +1,120 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+"use strict";
+// loaders.gl, MIT license
+// Forked from https://github.com/cschwarz/wkx under MIT license, Copyright (c) 2013 Christian Schwarz
+Object.defineProperty(exports, "__esModule", { value: true });
 const LE = true;
 const BE = false;
-export default class BinaryWriter {
-  constructor(size, allowResize) {
-    _defineProperty(this, "arrayBuffer", void 0);
-
-    _defineProperty(this, "dataView", void 0);
-
-    _defineProperty(this, "byteOffset", 0);
-
-    _defineProperty(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');
-      }
-    }
-  }
-
+class BinaryWriter {
+    constructor(size, allowResize) {
+        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;
+    }
+    /** 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
+exports.default = BinaryWriter;