@loaders.gl/wkt 3.4.11 → 3.4.12

package/dist/es5/lib/utils/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.VERSION = void 0;
-var VERSION = typeof "3.4.11" !== 'undefined' ? "3.4.11" : 'latest';
+var VERSION = typeof "3.4.12" !== 'undefined' ? "3.4.12" : 'latest';
 exports.VERSION = VERSION;
 //# sourceMappingURL=version.js.map

package/dist/esm/lib/utils/version.js

@@ -1,2 +1,2 @@
-export const VERSION = typeof "3.4.11" !== 'undefined' ? "3.4.11" : 'latest';
+export const VERSION = typeof "3.4.12" !== 'undefined' ? "3.4.12" : 'latest';
 //# sourceMappingURL=version.js.map

package/dist/wkt-worker.js

@@ -184,7 +184,7 @@
   }
 
   // src/lib/utils/version.ts
-  var VERSION = true ? "3.4.11" : "latest";
+  var VERSION = true ? "3.4.12" : "latest";
 
   // src/lib/parse-wkt.ts
   var numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/wkt",
   "description": "Loader and Writer for the WKT (Well Known Text) Format",
-  "version": "3.4.11",
+  "version": "3.4.12",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -35,8 +35,8 @@
     "fuzzer": "^0.2.1"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "3.4.11",
-    "@loaders.gl/schema": "3.4.11"
+    "@loaders.gl/loader-utils": "3.4.12",
+    "@loaders.gl/schema": "3.4.12"
   },
-  "gitHead": "2b8d490d2372e70dd89eef8f6b215a5205c16621"
+  "gitHead": "85254762ae3082f608a863291deef09f2b40c6cf"
 }

package/dist/bundle.js

@@ -1,5 +0,0 @@
-"use strict";
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/index.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WKBWriter = exports.WKTWriter = exports.WKTWorkerLoader = exports.WKTLoader = exports.WKBWorkerLoader = exports.WKBLoader = void 0;
-var wkb_loader_1 = require("./wkb-loader");
-Object.defineProperty(exports, "WKBLoader", { enumerable: true, get: function () { return wkb_loader_1.WKBLoader; } });
-Object.defineProperty(exports, "WKBWorkerLoader", { enumerable: true, get: function () { return wkb_loader_1.WKBWorkerLoader; } });
-var wkt_loader_1 = require("./wkt-loader");
-Object.defineProperty(exports, "WKTLoader", { enumerable: true, get: function () { return wkt_loader_1.WKTLoader; } });
-Object.defineProperty(exports, "WKTWorkerLoader", { enumerable: true, get: function () { return wkt_loader_1.WKTWorkerLoader; } });
-var wkt_writer_1 = require("./wkt-writer");
-Object.defineProperty(exports, "WKTWriter", { enumerable: true, get: function () { return wkt_writer_1.WKTWriter; } });
-var wkb_writer_1 = require("./wkb-writer");
-Object.defineProperty(exports, "WKBWriter", { enumerable: true, get: function () { return wkb_writer_1.WKBWriter; } });

package/dist/lib/encode-wkb.js

@@ -1,295 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-// Forked from https://github.com/cschwarz/wkx under MIT license, Copyright (c) 2013 Christian Schwarz
-// Reference: https://www.ogc.org/standards/sfa
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const binary_writer_1 = __importDefault(require("./utils/binary-writer"));
-/**
- * Integer code for geometry type
- * Reference: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
- */
-var WKB;
-(function (WKB) {
-    WKB[WKB["Point"] = 1] = "Point";
-    WKB[WKB["LineString"] = 2] = "LineString";
-    WKB[WKB["Polygon"] = 3] = "Polygon";
-    WKB[WKB["MultiPoint"] = 4] = "MultiPoint";
-    WKB[WKB["MultiLineString"] = 5] = "MultiLineString";
-    WKB[WKB["MultiPolygon"] = 6] = "MultiPolygon";
-    WKB[WKB["GeometryCollection"] = 7] = "GeometryCollection";
-})(WKB || (WKB = {}));
-/**
- * Encodes a GeoJSON object into WKB
- * @param geojson A GeoJSON Feature or Geometry
- * @returns string
- */
-function encodeWKB(geometry, options = {}) {
-    if (geometry.type === 'Feature') {
-        geometry = geometry.geometry;
-    }
-    // Options should be wrapped in a `wkb` key, but we allow top-level options here for backwards
-    // compatibility
-    if ('wkb' in options) {
-        options = options.wkb;
-    }
-    switch (geometry.type) {
-        case 'Point':
-            return encodePoint(geometry.coordinates, options);
-        case 'LineString':
-            return encodeLineString(geometry.coordinates, options);
-        case 'Polygon':
-            return encodePolygon(geometry.coordinates, options);
-        case 'MultiPoint':
-            return encodeMultiPoint(geometry, options);
-        case 'MultiPolygon':
-            return encodeMultiPolygon(geometry, options);
-        case 'MultiLineString':
-            return encodeMultiLineString(geometry, options);
-        case 'GeometryCollection':
-            return encodeGeometryCollection(geometry, options);
-        default:
-            const exhaustiveCheck = geometry;
-            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
-    }
-}
-exports.default = encodeWKB;
-/** Calculate the binary size (in the WKB encoding) of a specific GeoJSON geometry */
-function getGeometrySize(geometry, options) {
-    switch (geometry.type) {
-        case 'Point':
-            return getPointSize(options);
-        case 'LineString':
-            return getLineStringSize(geometry.coordinates, options);
-        case 'Polygon':
-            return getPolygonSize(geometry.coordinates, options);
-        case 'MultiPoint':
-            return getMultiPointSize(geometry, options);
-        case 'MultiPolygon':
-            return getMultiPolygonSize(geometry, options);
-        case 'MultiLineString':
-            return getMultiLineStringSize(geometry, options);
-        case 'GeometryCollection':
-            return getGeometryCollectionSize(geometry, options);
-        default:
-            const exhaustiveCheck = geometry;
-            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
-    }
-}
-/** Encode Point geometry as WKB ArrayBuffer */
-function encodePoint(coordinates, options) {
-    const writer = new binary_writer_1.default(getPointSize(options));
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.Point, options);
-    // I believe this special case is to handle writing Point(NaN, NaN) correctly
-    if (typeof coordinates[0] === 'undefined' && typeof coordinates[1] === 'undefined') {
-        writer.writeDoubleLE(NaN);
-        writer.writeDoubleLE(NaN);
-        if (options.hasZ) {
-            writer.writeDoubleLE(NaN);
-        }
-        if (options.hasM) {
-            writer.writeDoubleLE(NaN);
-        }
-    }
-    else {
-        writeCoordinate(writer, coordinates, options);
-    }
-    return writer.arrayBuffer;
-}
-/** Write coordinate to buffer */
-function writeCoordinate(writer, coordinate, options) {
-    writer.writeDoubleLE(coordinate[0]);
-    writer.writeDoubleLE(coordinate[1]);
-    if (options.hasZ) {
-        writer.writeDoubleLE(coordinate[2]);
-    }
-    if (options.hasM) {
-        writer.writeDoubleLE(coordinate[3]);
-    }
-}
-/** Get encoded size of Point geometry */
-function getPointSize(options) {
-    const coordinateSize = getCoordinateSize(options);
-    return 1 + 4 + coordinateSize;
-}
-/** Encode LineString geometry as WKB ArrayBuffer */
-function encodeLineString(coordinates, options) {
-    const size = getLineStringSize(coordinates, options);
-    const writer = new binary_writer_1.default(size);
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.LineString, options);
-    writer.writeUInt32LE(coordinates.length);
-    for (const coordinate of coordinates) {
-        writeCoordinate(writer, coordinate, options);
-    }
-    return writer.arrayBuffer;
-}
-/** Get encoded size of LineString geometry */
-function getLineStringSize(coordinates, options) {
-    const coordinateSize = getCoordinateSize(options);
-    return 1 + 4 + 4 + coordinates.length * coordinateSize;
-}
-/** Encode Polygon geometry as WKB ArrayBuffer */
-function encodePolygon(coordinates, options) {
-    const writer = new binary_writer_1.default(getPolygonSize(coordinates, options));
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.Polygon, options);
-    const [exteriorRing, ...interiorRings] = coordinates;
-    if (exteriorRing.length > 0) {
-        writer.writeUInt32LE(1 + interiorRings.length);
-        writer.writeUInt32LE(exteriorRing.length);
-    }
-    else {
-        writer.writeUInt32LE(0);
-    }
-    for (const coordinate of exteriorRing) {
-        writeCoordinate(writer, coordinate, options);
-    }
-    for (const interiorRing of interiorRings) {
-        writer.writeUInt32LE(interiorRing.length);
-        for (const coordinate of interiorRing) {
-            writeCoordinate(writer, coordinate, options);
-        }
-    }
-    return writer.arrayBuffer;
-}
-/** Get encoded size of Polygon geometry */
-function getPolygonSize(coordinates, options) {
-    const coordinateSize = getCoordinateSize(options);
-    const [exteriorRing, ...interiorRings] = coordinates;
-    let size = 1 + 4 + 4;
-    if (exteriorRing.length > 0) {
-        size += 4 + exteriorRing.length * coordinateSize;
-    }
-    for (const interiorRing of interiorRings) {
-        size += 4 + interiorRing.length * coordinateSize;
-    }
-    return size;
-}
-/** Encode MultiPoint geometry as WKB ArrayBufer */
-function encodeMultiPoint(multiPoint, options) {
-    const writer = new binary_writer_1.default(getMultiPointSize(multiPoint, options));
-    const points = multiPoint.coordinates;
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.MultiPoint, options);
-    writer.writeUInt32LE(points.length);
-    for (const point of points) {
-        // TODO: add srid to this options object? {srid: multiPoint.srid}
-        const arrayBuffer = encodePoint(point, options);
-        writer.writeBuffer(arrayBuffer);
-    }
-    return writer.arrayBuffer;
-}
-/** Get encoded size of MultiPoint geometry */
-function getMultiPointSize(multiPoint, options) {
-    let coordinateSize = getCoordinateSize(options);
-    const points = multiPoint.coordinates;
-    // This is because each point has a 5-byte header?
-    coordinateSize += 5;
-    return 1 + 4 + 4 + points.length * coordinateSize;
-}
-/** Encode MultiLineString geometry as WKB ArrayBufer */
-function encodeMultiLineString(multiLineString, options) {
-    const writer = new binary_writer_1.default(getMultiLineStringSize(multiLineString, options));
-    const lineStrings = multiLineString.coordinates;
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.MultiLineString, options);
-    writer.writeUInt32LE(lineStrings.length);
-    for (const lineString of lineStrings) {
-        // TODO: Handle srid?
-        const encodedLineString = encodeLineString(lineString, options);
-        writer.writeBuffer(encodedLineString);
-    }
-    return writer.arrayBuffer;
-}
-/** Get encoded size of MultiLineString geometry */
-function getMultiLineStringSize(multiLineString, options) {
-    let size = 1 + 4 + 4;
-    const lineStrings = multiLineString.coordinates;
-    for (const lineString of lineStrings) {
-        size += getLineStringSize(lineString, options);
-    }
-    return size;
-}
-function encodeMultiPolygon(multiPolygon, options) {
-    const writer = new binary_writer_1.default(getMultiPolygonSize(multiPolygon, options));
-    const polygons = multiPolygon.coordinates;
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.MultiPolygon, options);
-    writer.writeUInt32LE(polygons.length);
-    for (const polygon of polygons) {
-        const encodedPolygon = encodePolygon(polygon, options);
-        writer.writeBuffer(encodedPolygon);
-    }
-    return writer.arrayBuffer;
-}
-function getMultiPolygonSize(multiPolygon, options) {
-    let size = 1 + 4 + 4;
-    const polygons = multiPolygon.coordinates;
-    for (const polygon of polygons) {
-        size += getPolygonSize(polygon, options);
-    }
-    return size;
-}
-function encodeGeometryCollection(collection, options) {
-    const writer = new binary_writer_1.default(getGeometryCollectionSize(collection, options));
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.GeometryCollection, options);
-    writer.writeUInt32LE(collection.geometries.length);
-    for (const geometry of collection.geometries) {
-        // TODO: handle srid? {srid: collection.srid}
-        const arrayBuffer = encodeWKB(geometry, options);
-        writer.writeBuffer(arrayBuffer);
-    }
-    return writer.arrayBuffer;
-}
-function getGeometryCollectionSize(collection, options) {
-    let size = 1 + 4 + 4;
-    for (const geometry of collection.geometries) {
-        size += getGeometrySize(geometry, options);
-    }
-    return size;
-}
-// HELPERS
-/**
- * Construct and write WKB integer code
- * Reference: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
- */
-function writeWkbType(writer, geometryType, options) {
-    const { hasZ, hasM, srid } = options;
-    let dimensionType = 0;
-    if (!srid) {
-        if (hasZ && hasM) {
-            dimensionType += 3000;
-        }
-        else if (hasZ) {
-            dimensionType += 1000;
-        }
-        else if (hasM) {
-            dimensionType += 2000;
-        }
-    }
-    else {
-        if (hasZ) {
-            dimensionType |= 0x80000000;
-        }
-        if (hasM) {
-            dimensionType |= 0x40000000;
-        }
-    }
-    writer.writeUInt32LE((dimensionType + geometryType) >>> 0);
-}
-/** Get coordinate size given Z/M dimensions */
-function getCoordinateSize(options) {
-    let coordinateSize = 16;
-    if (options.hasZ) {
-        coordinateSize += 8;
-    }
-    if (options.hasM) {
-        coordinateSize += 8;
-    }
-    return coordinateSize;
-}

package/dist/lib/encode-wkt.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Stringifies a GeoJSON object into WKT
- * @param geojson
- * @returns string
- */
-function encodeWKT(geometry) {
-    if (geometry.type === 'Feature') {
-        geometry = geometry.geometry;
-    }
-    switch (geometry.type) {
-        case 'Point':
-            return `POINT ${wrapParens(pairWKT(geometry.coordinates))}`;
-        case 'LineString':
-            return `LINESTRING ${wrapParens(ringWKT(geometry.coordinates))}`;
-        case 'Polygon':
-            return `POLYGON ${wrapParens(ringsWKT(geometry.coordinates))}`;
-        case 'MultiPoint':
-            return `MULTIPOINT ${wrapParens(ringWKT(geometry.coordinates))}`;
-        case 'MultiPolygon':
-            return `MULTIPOLYGON ${wrapParens(multiRingsWKT(geometry.coordinates))}`;
-        case 'MultiLineString':
-            return `MULTILINESTRING ${wrapParens(ringsWKT(geometry.coordinates))}`;
-        case 'GeometryCollection':
-            return `GEOMETRYCOLLECTION ${wrapParens(geometry.geometries.map(encodeWKT).join(', '))}`;
-        default:
-            throw new Error('stringify requires a valid GeoJSON Feature or geometry object as input');
-    }
-}
-exports.default = encodeWKT;
-function pairWKT(c) {
-    return c.join(' ');
-}
-function ringWKT(r) {
-    return r.map(pairWKT).join(', ');
-}
-function ringsWKT(r) {
-    return r.map(ringWKT).map(wrapParens).join(', ');
-}
-function multiRingsWKT(r) {
-    return r.map(ringsWKT).map(wrapParens).join(', ');
-}
-function wrapParens(s) {
-    return `(${s})`;
-}

package/dist/lib/parse-wkb.js

@@ -1,236 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const NUM_DIMENSIONS = {
-    0: 2,
-    1: 3,
-    2: 3,
-    3: 4 // 4D (ZM)
-};
-function parseWKB(arrayBuffer) {
-    const view = new DataView(arrayBuffer);
-    let offset = 0;
-    // Check endianness of data
-    const littleEndian = view.getUint8(offset) === 1;
-    offset++;
-    // 4-digit code representing dimension and type of geometry
-    const geometryCode = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const geometryType = geometryCode % 1000;
-    const type = ((geometryCode - geometryType) / 1000);
-    const dimension = NUM_DIMENSIONS[type];
-    switch (geometryType) {
-        case 1:
-            const point = parsePoint(view, offset, dimension, littleEndian);
-            return point.geometry;
-        case 2:
-            const line = parseLineString(view, offset, dimension, littleEndian);
-            return line.geometry;
-        case 3:
-            const polygon = parsePolygon(view, offset, dimension, littleEndian);
-            return polygon.geometry;
-        case 4:
-            const multiPoint = parseMultiPoint(view, offset, dimension, littleEndian);
-            multiPoint.type = 'Point';
-            return multiPoint;
-        case 5:
-            const multiLine = parseMultiLineString(view, offset, dimension, littleEndian);
-            multiLine.type = 'LineString';
-            return multiLine;
-        case 6:
-            const multiPolygon = parseMultiPolygon(view, offset, dimension, littleEndian);
-            multiPolygon.type = 'Polygon';
-            return multiPolygon;
-        // case 7:
-        // TODO: handle GeometryCollections
-        // return parseGeometryCollection(view, offset, dimension, littleEndian);
-        default:
-            throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
-    }
-}
-exports.default = parseWKB;
-// Primitives; parse point and linear ring
-function parsePoint(view, offset, dimension, littleEndian) {
-    const positions = new Float64Array(dimension);
-    for (let i = 0; i < dimension; i++) {
-        positions[i] = view.getFloat64(offset, littleEndian);
-        offset += 8;
-    }
-    return {
-        geometry: { type: 'Point', positions: { value: positions, size: dimension } },
-        offset
-    };
-}
-function parseLineString(view, offset, dimension, littleEndian) {
-    const nPoints = view.getUint32(offset, littleEndian);
-    offset += 4;
-    // Instantiate array
-    const positions = new Float64Array(nPoints * dimension);
-    for (let i = 0; i < nPoints * dimension; i++) {
-        positions[i] = view.getFloat64(offset, littleEndian);
-        offset += 8;
-    }
-    const pathIndices = [0];
-    if (nPoints > 0) {
-        pathIndices.push(nPoints);
-    }
-    return {
-        geometry: {
-            type: 'LineString',
-            positions: { value: positions, size: dimension },
-            pathIndices: { value: new Uint16Array(pathIndices), size: 1 }
-        },
-        offset
-    };
-}
-// https://stackoverflow.com/a/55261098
-const cumulativeSum = (sum) => (value) => (sum += value);
-function parsePolygon(view, offset, dimension, littleEndian) {
-    const nRings = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const rings = [];
-    for (let i = 0; i < nRings; i++) {
-        const parsed = parseLineString(view, offset, dimension, littleEndian);
-        const { positions } = parsed.geometry;
-        offset = parsed.offset;
-        rings.push(positions.value);
-    }
-    const concatenatedPositions = new Float64Array(concatTypedArrays(rings).buffer);
-    const polygonIndices = [0];
-    if (concatenatedPositions.length > 0) {
-        polygonIndices.push(concatenatedPositions.length / dimension);
-    }
-    const primitivePolygonIndices = rings.map((l) => l.length / dimension).map(cumulativeSum(0));
-    primitivePolygonIndices.unshift(0);
-    return {
-        geometry: {
-            type: 'Polygon',
-            positions: { value: concatenatedPositions, size: dimension },
-            polygonIndices: {
-                value: new Uint16Array(polygonIndices),
-                size: 1
-            },
-            primitivePolygonIndices: { value: new Uint16Array(primitivePolygonIndices), size: 1 }
-        },
-        offset
-    };
-}
-function parseMultiPoint(view, offset, dimension, littleEndian) {
-    const nPoints = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryPointGeometries = [];
-    for (let i = 0; i < nPoints; i++) {
-        // Byte order for point
-        const littleEndianPoint = view.getUint8(offset) === 1;
-        offset++;
-        // Assert point type
-        if (view.getUint32(offset, littleEndianPoint) % 1000 !== 1) {
-            throw new Error('WKB: Inner geometries of MultiPoint not of type Point');
-        }
-        offset += 4;
-        const parsed = parsePoint(view, offset, dimension, littleEndianPoint);
-        offset = parsed.offset;
-        binaryPointGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
-}
-function parseMultiLineString(view, offset, dimension, littleEndian) {
-    const nLines = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryLineGeometries = [];
-    for (let i = 0; i < nLines; i++) {
-        // Byte order for line
-        const littleEndianLine = view.getUint8(offset) === 1;
-        offset++;
-        // Assert type LineString
-        if (view.getUint32(offset, littleEndianLine) % 1000 !== 2) {
-            throw new Error('WKB: Inner geometries of MultiLineString not of type LineString');
-        }
-        offset += 4;
-        const parsed = parseLineString(view, offset, dimension, littleEndianLine);
-        offset = parsed.offset;
-        binaryLineGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
-}
-function parseMultiPolygon(view, offset, dimension, littleEndian) {
-    const nPolygons = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryPolygonGeometries = [];
-    for (let i = 0; i < nPolygons; i++) {
-        // Byte order for polygon
-        const littleEndianPolygon = view.getUint8(offset) === 1;
-        offset++;
-        // Assert type Polygon
-        if (view.getUint32(offset, littleEndianPolygon) % 1000 !== 3) {
-            throw new Error('WKB: Inner geometries of MultiPolygon not of type Polygon');
-        }
-        offset += 4;
-        const parsed = parsePolygon(view, offset, dimension, littleEndianPolygon);
-        offset = parsed.offset;
-        binaryPolygonGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension);
-}
-// TODO - move to loaders.gl/schema/gis
-function concatenateBinaryPointGeometries(binaryPointGeometries, dimension) {
-    const positions = binaryPointGeometries.map((geometry) => geometry.positions.value);
-    const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
-    return {
-        type: 'Point',
-        positions: { value: concatenatedPositions, size: dimension }
-    };
-}
-function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
-    const lines = binaryLineGeometries.map((geometry) => geometry.positions.value);
-    const concatenatedPositions = new Float64Array(concatTypedArrays(lines).buffer);
-    const pathIndices = lines.map((line) => line.length / dimension).map(cumulativeSum(0));
-    pathIndices.unshift(0);
-    return {
-        type: 'LineString',
-        positions: { value: concatenatedPositions, size: dimension },
-        pathIndices: { value: new Uint16Array(pathIndices), size: 1 }
-    };
-}
-function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
-    const polygons = [];
-    const primitivePolygons = [];
-    for (const binaryPolygon of binaryPolygonGeometries) {
-        const { positions, primitivePolygonIndices } = binaryPolygon;
-        polygons.push(positions.value);
-        primitivePolygons.push(primitivePolygonIndices.value);
-    }
-    const concatenatedPositions = new Float64Array(concatTypedArrays(polygons).buffer);
-    const polygonIndices = polygons.map((p) => p.length / dimension).map(cumulativeSum(0));
-    polygonIndices.unshift(0);
-    // Combine primitivePolygonIndices from each individual polygon
-    const primitivePolygonIndices = [0];
-    for (const primitivePolygon of primitivePolygons) {
-        primitivePolygonIndices.push(...primitivePolygon
-            .filter((x) => x > 0)
-            .map((x) => x + primitivePolygonIndices[primitivePolygonIndices.length - 1]));
-    }
-    return {
-        type: 'Polygon',
-        positions: { value: concatenatedPositions, size: dimension },
-        polygonIndices: { value: new Uint16Array(polygonIndices), size: 1 },
-        primitivePolygonIndices: { value: new Uint16Array(primitivePolygonIndices), size: 1 }
-    };
-}
-// TODO: remove copy; import from typed-array-utils
-// modules/math/src/geometry/typed-arrays/typed-array-utils.js
-function concatTypedArrays(arrays) {
-    let byteLength = 0;
-    for (let i = 0; i < arrays.length; ++i) {
-        byteLength += arrays[i].byteLength;
-    }
-    const buffer = new Uint8Array(byteLength);
-    let byteOffset = 0;
-    for (let i = 0; i < arrays.length; ++i) {
-        const data = new Uint8Array(arrays[i].buffer);
-        byteLength = data.length;
-        for (let j = 0; j < byteLength; ++j) {
-            buffer[byteOffset++] = data[j];
-        }
-    }
-    return buffer;
-}

package/dist/lib/parse-wkt.js

@@ -1,227 +0,0 @@
-"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,}');
-/**
- * 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 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;
-    }
-    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();
-        }
-        if (!$(/^(\))/))
-            return null;
-        return {
-            type: 'GeometryCollection',
-            geometries: geometries
-        };
-    }
-    function root() {
-        return (point() ||
-            linestring() ||
-            polygon() ||
-            multipoint() ||
-            multilinestring() ||
-            multipolygon() ||
-            geometrycollection());
-    }
-    return crs(root());
-}
-exports.default = parseWKT;

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

@@ -1,120 +0,0 @@
-"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;
-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');
-            }
-        }
-    }
-}
-exports.default = BinaryWriter;

package/dist/lib/utils/version.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = void 0;
-// Version constant cannot be imported, it needs to correspond to the build version of **this** module.
-// __VERSION__ is injected by babel-plugin-version-inline
-// @ts-ignore TS2304: Cannot find name '__VERSION__'.
-exports.VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';

package/dist/wkb-loader.js

@@ -1,34 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckWKBLoader = exports._typecheckWKBWorkerLoader = exports.WKBLoader = exports.WKBWorkerLoader = void 0;
-const version_1 = require("./lib/utils/version");
-const parse_wkb_1 = __importDefault(require("./lib/parse-wkb"));
-/**
- * Worker loader for WKB (Well-Known Binary)
- */
-exports.WKBWorkerLoader = {
-    name: 'WKB',
-    id: 'wkb',
-    module: 'wkt',
-    version: version_1.VERSION,
-    worker: true,
-    category: 'geometry',
-    extensions: ['wkb'],
-    mimeTypes: [],
-    options: {
-        wkb: {}
-    }
-};
-/**
- * Loader for WKB (Well-Known Binary)
- */
-exports.WKBLoader = {
-    ...exports.WKBWorkerLoader,
-    parse: async (arrayBuffer) => (0, parse_wkb_1.default)(arrayBuffer),
-    parseSync: parse_wkb_1.default
-};
-exports._typecheckWKBWorkerLoader = exports.WKBWorkerLoader;
-exports._typecheckWKBLoader = exports.WKBLoader;

package/dist/wkb-writer.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WKBWriter = void 0;
-const version_1 = require("./lib/utils/version");
-const encode_wkb_1 = __importDefault(require("./lib/encode-wkb"));
-/**
- * WKB exporter
- */
-exports.WKBWriter = {
-    name: 'WKB (Well Known Binary)',
-    id: 'wkb',
-    module: 'wkt',
-    version: version_1.VERSION,
-    extensions: ['wkb'],
-    // @ts-ignore
-    encodeSync: encode_wkb_1.default,
-    options: {
-        wkb: {
-            hasZ: false,
-            hasM: false
-        }
-    }
-};

package/dist/wkt-loader.js

@@ -1,33 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WKTLoader = exports.WKTWorkerLoader = void 0;
-const version_1 = require("./lib/utils/version");
-const parse_wkt_1 = __importDefault(require("./lib/parse-wkt"));
-/**
- * Well-Known text loader
- */
-exports.WKTWorkerLoader = {
-    name: 'WKT (Well-Known Text)',
-    id: 'wkt',
-    module: 'wkt',
-    version: version_1.VERSION,
-    worker: true,
-    extensions: ['wkt'],
-    mimeTypes: ['text/plain'],
-    category: 'geometry',
-    text: true,
-    options: {
-        wkt: {}
-    }
-};
-/**
- * Well-Known text loader
- */
-exports.WKTLoader = {
-    ...exports.WKTWorkerLoader,
-    parse: async (arrayBuffer) => (0, parse_wkt_1.default)(new TextDecoder().decode(arrayBuffer)),
-    parseTextSync: parse_wkt_1.default
-};

package/dist/wkt-writer.js

@@ -1,23 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WKTWriter = void 0;
-const version_1 = require("./lib/utils/version");
-const encode_wkt_1 = __importDefault(require("./lib/encode-wkt"));
-/**
- * WKT exporter
- */
-exports.WKTWriter = {
-    name: 'WKT (Well Known Text)',
-    id: 'wkt',
-    module: 'wkt',
-    version: version_1.VERSION,
-    extensions: ['wkt'],
-    // @ts-ignore
-    encode: encode_wkt_1.default,
-    options: {
-        wkt: {}
-    }
-};

package/dist/workers/wkb-worker.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const wkb_loader_1 = require("../wkb-loader");
-(0, loader_utils_1.createLoaderWorker)(wkb_loader_1.WKBLoader);

package/dist/workers/wkt-worker.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const wkt_loader_1 = require("../wkt-loader");
-(0, loader_utils_1.createLoaderWorker)(wkt_loader_1.WKTLoader);