@loaders.gl/wkt 4.3.2 → 4.4.0-alpha.2

package/dist/lib/parse-twkb.js

@@ -1,253 +0,0 @@
-// 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
-import { BinaryReader } from "./utils/binary-reader.js";
-import { WKBGeometryType } from "./parse-wkb-header.js";
-/**
- * Check if an array buffer might be a TWKB array buffer
- * @param arrayBuffer The array buffer to check
- * @returns false if this is definitely not a TWKB array buffer, true if it might be a TWKB array buffer
- */
-export function isTWKB(arrayBuffer) {
-    const binaryReader = new BinaryReader(arrayBuffer);
-    const type = binaryReader.readUInt8();
-    const geometryType = type & 0x0f;
-    // Only geometry types 1 to 7 (point to geometry collection are currently defined)
-    if (geometryType < 1 || geometryType > 7) {
-        return false;
-    }
-    return true;
-}
-export function parseTWKBGeometry(arrayBuffer) {
-    const binaryReader = new BinaryReader(arrayBuffer);
-    const context = parseTWKBHeader(binaryReader);
-    if (context.hasSizeAttribute) {
-        binaryReader.readVarInt();
-    }
-    if (context.hasBoundingBox) {
-        let dimensions = 2;
-        if (context.hasZ) {
-            dimensions++;
-        }
-        if (context.hasM) {
-            dimensions++;
-        }
-        // TODO why are we throwing away these datums?
-        for (let i = 0; i < dimensions; i++) {
-            binaryReader.readVarInt();
-            binaryReader.readVarInt();
-        }
-    }
-    return parseGeometry(binaryReader, context, context.geometryType);
-}
-function parseTWKBHeader(binaryReader) {
-    const type = binaryReader.readUInt8();
-    const metadataHeader = binaryReader.readUInt8();
-    const geometryType = type & 0x0f;
-    const precision = zigZagDecode(type >> 4);
-    const hasExtendedPrecision = Boolean((metadataHeader >> 3) & 1);
-    let hasZ = false;
-    let hasM = false;
-    let zPrecision = 0;
-    let zPrecisionFactor = 1;
-    let mPrecision = 0;
-    let mPrecisionFactor = 1;
-    if (hasExtendedPrecision) {
-        const extendedPrecision = binaryReader.readUInt8();
-        hasZ = (extendedPrecision & 0x01) === 0x01;
-        hasM = (extendedPrecision & 0x02) === 0x02;
-        zPrecision = zigZagDecode((extendedPrecision & 0x1c) >> 2);
-        zPrecisionFactor = Math.pow(10, zPrecision);
-        mPrecision = zigZagDecode((extendedPrecision & 0xe0) >> 5);
-        mPrecisionFactor = Math.pow(10, mPrecision);
-    }
-    return {
-        geometryType,
-        precision,
-        precisionFactor: Math.pow(10, precision),
-        hasBoundingBox: Boolean((metadataHeader >> 0) & 1),
-        hasSizeAttribute: Boolean((metadataHeader >> 1) & 1),
-        hasIdList: Boolean((metadataHeader >> 2) & 1),
-        hasExtendedPrecision,
-        isEmpty: Boolean((metadataHeader >> 4) & 1),
-        hasZ,
-        hasM,
-        zPrecision,
-        zPrecisionFactor,
-        mPrecision,
-        mPrecisionFactor
-    };
-}
-function parseGeometry(binaryReader, context, geometryType) {
-    switch (geometryType) {
-        case WKBGeometryType.Point:
-            return parsePoint(binaryReader, context);
-        case WKBGeometryType.LineString:
-            return parseLineString(binaryReader, context);
-        case WKBGeometryType.Polygon:
-            return parsePolygon(binaryReader, context);
-        case WKBGeometryType.MultiPoint:
-            return parseMultiPoint(binaryReader, context);
-        case WKBGeometryType.MultiLineString:
-            return parseMultiLineString(binaryReader, context);
-        case WKBGeometryType.MultiPolygon:
-            return parseMultiPolygon(binaryReader, context);
-        case WKBGeometryType.GeometryCollection:
-            return parseGeometryCollection(binaryReader, context);
-        default:
-            throw new Error(`GeometryType ${geometryType} not supported`);
-    }
-}
-// GEOMETRIES
-function parsePoint(reader, context) {
-    if (context.isEmpty) {
-        return { type: 'Point', coordinates: [] };
-    }
-    return { type: 'Point', coordinates: readFirstPoint(reader, context) };
-}
-function parseLineString(reader, context) {
-    if (context.isEmpty) {
-        return { type: 'LineString', coordinates: [] };
-    }
-    const pointCount = reader.readVarInt();
-    const previousPoint = makePreviousPoint(context);
-    const points = [];
-    for (let i = 0; i < pointCount; i++) {
-        points.push(parseNextPoint(reader, context, previousPoint));
-    }
-    return { type: 'LineString', coordinates: points };
-}
-function parsePolygon(reader, context) {
-    if (context.isEmpty) {
-        return { type: 'Polygon', coordinates: [] };
-    }
-    const ringCount = reader.readVarInt();
-    const previousPoint = makePreviousPoint(context);
-    const exteriorRingLength = reader.readVarInt();
-    const exteriorRing = [];
-    for (let i = 0; i < exteriorRingLength; i++) {
-        exteriorRing.push(parseNextPoint(reader, context, previousPoint));
-    }
-    const polygon = [exteriorRing];
-    for (let i = 1; i < ringCount; i++) {
-        const interiorRingCount = reader.readVarInt();
-        const interiorRing = [];
-        for (let j = 0; j < interiorRingCount; j++) {
-            interiorRing.push(parseNextPoint(reader, context, previousPoint));
-        }
-        polygon.push(interiorRing);
-    }
-    return { type: 'Polygon', coordinates: polygon };
-}
-function parseMultiPoint(reader, context) {
-    if (context.isEmpty) {
-        return { type: 'MultiPoint', coordinates: [] };
-    }
-    const previousPoint = makePreviousPoint(context);
-    const pointCount = reader.readVarInt();
-    const coordinates = [];
-    for (let i = 0; i < pointCount; i++) {
-        coordinates.push(parseNextPoint(reader, context, previousPoint));
-    }
-    return { type: 'MultiPoint', coordinates };
-}
-function parseMultiLineString(reader, context) {
-    if (context.isEmpty) {
-        return { type: 'MultiLineString', coordinates: [] };
-    }
-    const previousPoint = makePreviousPoint(context);
-    const lineStringCount = reader.readVarInt();
-    const coordinates = [];
-    for (let i = 0; i < lineStringCount; i++) {
-        const pointCount = reader.readVarInt();
-        const lineString = [];
-        for (let j = 0; j < pointCount; j++) {
-            lineString.push(parseNextPoint(reader, context, previousPoint));
-        }
-        coordinates.push(lineString);
-    }
-    return { type: 'MultiLineString', coordinates };
-}
-function parseMultiPolygon(reader, context) {
-    if (context.isEmpty) {
-        return { type: 'MultiPolygon', coordinates: [] };
-    }
-    const previousPoint = makePreviousPoint(context);
-    const polygonCount = reader.readVarInt();
-    const polygons = [];
-    for (let i = 0; i < polygonCount; i++) {
-        const ringCount = reader.readVarInt();
-        const exteriorPointCount = reader.readVarInt();
-        const exteriorRing = [];
-        for (let j = 0; j < exteriorPointCount; j++) {
-            exteriorRing.push(parseNextPoint(reader, context, previousPoint));
-        }
-        const polygon = exteriorRing ? [exteriorRing] : [];
-        for (let j = 1; j < ringCount; j++) {
-            const interiorRing = [];
-            const interiorRingLength = reader.readVarInt();
-            for (let k = 0; k < interiorRingLength; k++) {
-                interiorRing.push(parseNextPoint(reader, context, previousPoint));
-            }
-            polygon.push(interiorRing);
-        }
-        polygons.push(polygon);
-    }
-    return { type: 'MultiPolygon', coordinates: polygons };
-}
-/** Geometry collection not yet supported */
-function parseGeometryCollection(reader, context) {
-    return { type: 'GeometryCollection', geometries: [] };
-    /**
-    if (context.isEmpty) {
-      return {type: 'GeometryCollection', geometries: []};
-    }
-  
-    const geometryCount = reader.readVarInt();
-  
-    const geometries: Geometry[] = new Array(geometryCount);
-    for (let i = 0; i < geometryCount; i++) {
-      const geometry = parseGeometry(reader, context, geometryType);
-      geometries.push(geometry);
-    }
-  
-    return {type: 'GeometryCollection', geometries: []};
-    */
-}
-// HELPERS
-/**
- * Maps negative values to positive values while going back and
-  forth (0 = 0, -1 = 1, 1 = 2, -2 = 3, 2 = 4, -3 = 5, 3 = 6 ...)
- */
-function zigZagDecode(value) {
-    return (value >> 1) ^ -(value & 1);
-}
-function makePointCoordinates(x, y, z, m) {
-    return (z !== undefined ? (m !== undefined ? [x, y, z, m] : [x, y, z]) : [x, y]);
-}
-function makePreviousPoint(context) {
-    return makePointCoordinates(0, 0, context.hasZ ? 0 : undefined, context.hasM ? 0 : undefined);
-}
-function readFirstPoint(reader, context) {
-    const x = zigZagDecode(reader.readVarInt()) / context.precisionFactor;
-    const y = zigZagDecode(reader.readVarInt()) / context.precisionFactor;
-    const z = context.hasZ ? zigZagDecode(reader.readVarInt()) / context.zPrecisionFactor : undefined;
-    const m = context.hasM ? zigZagDecode(reader.readVarInt()) / context.mPrecisionFactor : undefined;
-    return makePointCoordinates(x, y, z, m);
-}
-/**
- * Modifies previousPoint
- */
-function parseNextPoint(reader, context, previousPoint) {
-    previousPoint[0] += zigZagDecode(reader.readVarInt()) / context.precisionFactor;
-    previousPoint[1] += zigZagDecode(reader.readVarInt()) / context.precisionFactor;
-    if (context.hasZ) {
-        previousPoint[2] += zigZagDecode(reader.readVarInt()) / context.zPrecisionFactor;
-    }
-    if (context.hasM) {
-        previousPoint[3] += zigZagDecode(reader.readVarInt()) / context.mPrecisionFactor;
-    }
-    // Copy the point
-    return previousPoint.slice();
-}

package/dist/lib/parse-wkb-header.d.ts

@@ -1,39 +0,0 @@
-/**
- * Integer code for geometry types in WKB and related formats
- * Reference: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
- */
-export declare enum WKBGeometryType {
-    Point = 1,
-    LineString = 2,
-    Polygon = 3,
-    MultiPoint = 4,
-    MultiLineString = 5,
-    MultiPolygon = 6,
-    GeometryCollection = 7
-}
-/** Parsed WKB header */
-export type WKBHeader = {
-    /** WKB variant */
-    type: 'wkb' | 'ewkb' | 'iso-wkb' | 'twkb';
-    /** geometry type encoded in this WKB: point, line, polygon etc */
-    geometryType: 1 | 2 | 3 | 4 | 5 | 6 | 7;
-    /** Number of dimensions for coordinate data */
-    dimensions: 2 | 3 | 4;
-    /** Coordinate names, Z and M are controlled by flags */
-    coordinates: 'xy' | 'xyz' | 'xym' | 'xyzm';
-    srid?: number;
-    /** true if binary data is stored as little endian */
-    littleEndian: boolean;
-    /** Offset to start of geometry */
-    byteOffset: number;
-};
-/** Sanity checks that first to 5-9 bytes could represent a supported WKB dialect header */
-export declare function isWKB(arrayBuffer: ArrayBuffer): boolean;
-/**
- * Parses header and provides a byteOffset to start of geometry data
- * @param dataView
- * @param target optionally supply a WKBHeader object to avoid creating a new object for every call
- * @returns a header object describing the WKB data
- */
-export declare function parseWKBHeader(dataView: DataView, target?: WKBHeader): WKBHeader;
-//# sourceMappingURL=parse-wkb-header.d.ts.map

package/dist/lib/parse-wkb-header.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-wkb-header.d.ts","sourceRoot":"","sources":["../../src/lib/parse-wkb-header.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,oBAAY,eAAe;IACzB,KAAK,IAAI;IACT,UAAU,IAAI;IACd,OAAO,IAAI;IACX,UAAU,IAAI;IACd,eAAe,IAAI;IACnB,YAAY,IAAI;IAChB,kBAAkB,IAAI;CACvB;AAED,wBAAwB;AACxB,MAAM,MAAM,SAAS,GAAG;IACtB,kBAAkB;IAClB,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;IAC1C,kEAAkE;IAClE,YAAY,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACxC,+CAA+C;IAC/C,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtB,wDAAwD;IACxD,WAAW,EAAE,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,YAAY,EAAE,OAAO,CAAC;IACtB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,2FAA2F;AAC3F,wBAAgB,KAAK,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAkDvD;AAED;;;;;GAKG;AAEH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS,CAwEhF"}

package/dist/lib/parse-wkb-header.js

@@ -1,134 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-const EWKB_FLAG_Z = 0x80000000;
-const EWKB_FLAG_M = 0x40000000;
-const EWKB_FLAG_SRID = 0x20000000;
-const MAX_SRID = 10000; // TBD: Assume no more than 10K SRIDs are defined
-/**
- * Integer code for geometry types in WKB and related formats
- * Reference: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
- */
-export var WKBGeometryType;
-(function (WKBGeometryType) {
-    WKBGeometryType[WKBGeometryType["Point"] = 1] = "Point";
-    WKBGeometryType[WKBGeometryType["LineString"] = 2] = "LineString";
-    WKBGeometryType[WKBGeometryType["Polygon"] = 3] = "Polygon";
-    WKBGeometryType[WKBGeometryType["MultiPoint"] = 4] = "MultiPoint";
-    WKBGeometryType[WKBGeometryType["MultiLineString"] = 5] = "MultiLineString";
-    WKBGeometryType[WKBGeometryType["MultiPolygon"] = 6] = "MultiPolygon";
-    WKBGeometryType[WKBGeometryType["GeometryCollection"] = 7] = "GeometryCollection";
-})(WKBGeometryType || (WKBGeometryType = {}));
-/** Sanity checks that first to 5-9 bytes could represent a supported WKB dialect header */
-export function isWKB(arrayBuffer) {
-    const dataView = new DataView(arrayBuffer);
-    let byteOffset = 0;
-    const endianness = dataView.getUint8(byteOffset);
-    byteOffset += 1;
-    // Check valid endianness (only 0 or 1 are allowed)
-    if (endianness > 1) {
-        return false;
-    }
-    const littleEndian = endianness === 1;
-    const geometry = dataView.getUint32(byteOffset, littleEndian);
-    byteOffset += 4;
-    // check valid geometry type (we don't support extension geometries)
-    const geometryType = geometry & 0x07;
-    if (geometryType === 0 || geometryType > 7) {
-        return false;
-    }
-    const geometryFlags = geometry - geometryType;
-    // Accept iso-wkb flags
-    if (geometryFlags === 0 ||
-        geometryFlags === 1000 ||
-        geometryFlags === 2000 ||
-        geometryFlags === 3000) {
-        return true;
-    }
-    // Accept ewkb flags but reject otherwise
-    if ((geometryFlags & ~(EWKB_FLAG_Z | EWKB_FLAG_M | EWKB_FLAG_SRID)) !== 0) {
-        return false;
-    }
-    if (geometryFlags & EWKB_FLAG_SRID) {
-        const srid = dataView.getUint32(byteOffset, littleEndian);
-        byteOffset += 4;
-        if (srid > MAX_SRID) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Parses header and provides a byteOffset to start of geometry data
- * @param dataView
- * @param target optionally supply a WKBHeader object to avoid creating a new object for every call
- * @returns a header object describing the WKB data
- */
-// eslint-disable-next-line max-statements
-export function parseWKBHeader(dataView, target) {
-    const wkbHeader = Object.assign(target || {}, {
-        type: 'wkb',
-        geometryType: 1,
-        dimensions: 2,
-        coordinates: 'xy',
-        littleEndian: true,
-        byteOffset: 0
-    });
-    // Check endianness of data
-    wkbHeader.littleEndian = dataView.getUint8(wkbHeader.byteOffset) === 1;
-    wkbHeader.byteOffset++;
-    // 4-digit code representing dimension and type of geometry
-    const geometryCode = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
-    wkbHeader.byteOffset += 4;
-    wkbHeader.geometryType = (geometryCode & 0x7);
-    // Check if iso-wkb variant: iso-wkb adds 1000, 2000 or 3000 to the geometry code
-    const isoType = (geometryCode - wkbHeader.geometryType) / 1000;
-    switch (isoType) {
-        case 0:
-            break;
-        case 1:
-            wkbHeader.type = 'iso-wkb';
-            wkbHeader.dimensions = 3;
-            wkbHeader.coordinates = 'xyz';
-            break;
-        case 2:
-            wkbHeader.type = 'iso-wkb';
-            wkbHeader.dimensions = 3;
-            wkbHeader.coordinates = 'xym';
-            break;
-        case 3:
-            wkbHeader.type = 'iso-wkb';
-            wkbHeader.dimensions = 4;
-            wkbHeader.coordinates = 'xyzm';
-            break;
-        default:
-            throw new Error(`WKB: Unsupported iso-wkb type: ${isoType}`);
-    }
-    // Check if EWKB variant. Uses bitmasks for Z&M dimensions as well as optional SRID field
-    const ewkbZ = geometryCode & EWKB_FLAG_Z;
-    const ewkbM = geometryCode & EWKB_FLAG_M;
-    const ewkbSRID = geometryCode & EWKB_FLAG_SRID;
-    if (ewkbZ && ewkbM) {
-        wkbHeader.type = 'ewkb';
-        wkbHeader.dimensions = 4;
-        wkbHeader.coordinates = 'xyzm';
-    }
-    else if (ewkbZ) {
-        wkbHeader.type = 'ewkb';
-        wkbHeader.dimensions = 3;
-        wkbHeader.coordinates = 'xyz';
-    }
-    else if (ewkbM) {
-        wkbHeader.type = 'ewkb';
-        wkbHeader.dimensions = 3;
-        wkbHeader.coordinates = 'xym';
-    }
-    // If SRID present read four more bytes
-    if (ewkbSRID) {
-        wkbHeader.type = 'ewkb';
-        // 4-digit code representing dimension and type of geometry
-        wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
-        wkbHeader.byteOffset += 4;
-    }
-    return wkbHeader;
-}

package/dist/lib/parse-wkb.d.ts

@@ -1,5 +0,0 @@
-import type { BinaryGeometry, Geometry } from '@loaders.gl/schema';
-import type { WKBLoaderOptions } from "../wkb-loader.js";
-export declare function parseWKB(arrayBuffer: ArrayBuffer, options?: WKBLoaderOptions): BinaryGeometry | Geometry;
-export declare function parseWKBToBinary(arrayBuffer: ArrayBuffer, options?: WKBLoaderOptions): BinaryGeometry;
-//# sourceMappingURL=parse-wkb.d.ts.map

package/dist/lib/parse-wkb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-wkb.d.ts","sourceRoot":"","sources":["../../src/lib/parse-wkb.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,cAAc,EAId,QAAQ,EACT,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAC,gBAAgB,EAAC,yBAAsB;AAIpD,wBAAgB,QAAQ,CACtB,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,gBAAgB,GACzB,cAAc,GAAG,QAAQ,CAe3B;AAED,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,gBAAgB,GACzB,cAAc,CAoChB"}

package/dist/lib/parse-wkb.js

@@ -1,241 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { binaryToGeometry } from '@loaders.gl/gis';
-import { parseWKBHeader, WKBGeometryType } from "./parse-wkb-header.js";
-export function parseWKB(arrayBuffer, options) {
-    const binaryGeometry = parseWKBToBinary(arrayBuffer, options);
-    const shape = options?.wkb?.shape || 'binary-geometry';
-    switch (shape) {
-        case 'binary-geometry':
-            return binaryGeometry;
-        case 'geojson-geometry':
-            return binaryToGeometry(binaryGeometry);
-        case 'geometry':
-            // eslint-disable-next-line no-console
-            console.error('WKBLoader: "geometry" shape is deprecated, use "binary-geometry" instead');
-            return binaryToGeometry(binaryGeometry);
-        default:
-            throw new Error(shape);
-    }
-}
-export function parseWKBToBinary(arrayBuffer, options) {
-    const dataView = new DataView(arrayBuffer);
-    const wkbHeader = parseWKBHeader(dataView);
-    const { geometryType, dimensions, littleEndian } = wkbHeader;
-    const offset = wkbHeader.byteOffset;
-    switch (geometryType) {
-        case WKBGeometryType.Point:
-            const point = parsePoint(dataView, offset, dimensions, littleEndian);
-            return point.geometry;
-        case WKBGeometryType.LineString:
-            const line = parseLineString(dataView, offset, dimensions, littleEndian);
-            return line.geometry;
-        case WKBGeometryType.Polygon:
-            const polygon = parsePolygon(dataView, offset, dimensions, littleEndian);
-            return polygon.geometry;
-        case WKBGeometryType.MultiPoint:
-            const multiPoint = parseMultiPoint(dataView, offset, dimensions, littleEndian);
-            multiPoint.type = 'Point';
-            return multiPoint;
-        case WKBGeometryType.MultiLineString:
-            const multiLine = parseMultiLineString(dataView, offset, dimensions, littleEndian);
-            multiLine.type = 'LineString';
-            return multiLine;
-        case WKBGeometryType.MultiPolygon:
-            const multiPolygon = parseMultiPolygon(dataView, offset, dimensions, littleEndian);
-            multiPolygon.type = 'Polygon';
-            return multiPolygon;
-        // case WKBGeometryType.GeometryCollection:
-        // TODO: handle GeometryCollections
-        // return parseGeometryCollection(dataView, offset, dimensions, littleEndian);
-        default:
-            throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
-    }
-}
-// Primitives; parse point and linear ring
-function parsePoint(dataView, offset, dimension, littleEndian) {
-    const positions = new Float64Array(dimension);
-    for (let i = 0; i < dimension; i++) {
-        positions[i] = dataView.getFloat64(offset, littleEndian);
-        offset += 8;
-    }
-    return {
-        geometry: { type: 'Point', positions: { value: positions, size: dimension } },
-        offset
-    };
-}
-function parseLineString(dataView, offset, dimension, littleEndian) {
-    const nPoints = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    // Instantiate array
-    const positions = new Float64Array(nPoints * dimension);
-    for (let i = 0; i < nPoints * dimension; i++) {
-        positions[i] = dataView.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 Uint32Array(pathIndices), size: 1 }
-        },
-        offset
-    };
-}
-// https://stackoverflow.com/a/55261098
-const cumulativeSum = (sum) => (value) => (sum += value);
-function parsePolygon(dataView, offset, dimension, littleEndian) {
-    const nRings = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const rings = [];
-    for (let i = 0; i < nRings; i++) {
-        const parsed = parseLineString(dataView, 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 Uint32Array(polygonIndices),
-                size: 1
-            },
-            primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
-        },
-        offset
-    };
-}
-function parseMultiPoint(dataView, offset, dimension, littleEndian) {
-    const nPoints = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryPointGeometries = [];
-    for (let i = 0; i < nPoints; i++) {
-        // Byte order for point
-        const littleEndianPoint = dataView.getUint8(offset) === 1;
-        offset++;
-        // Assert point type
-        if (dataView.getUint32(offset, littleEndianPoint) % 1000 !== 1) {
-            throw new Error('WKB: Inner geometries of MultiPoint not of type Point');
-        }
-        offset += 4;
-        const parsed = parsePoint(dataView, offset, dimension, littleEndianPoint);
-        offset = parsed.offset;
-        binaryPointGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
-}
-function parseMultiLineString(dataView, offset, dimension, littleEndian) {
-    const nLines = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryLineGeometries = [];
-    for (let i = 0; i < nLines; i++) {
-        // Byte order for line
-        const littleEndianLine = dataView.getUint8(offset) === 1;
-        offset++;
-        // Assert type LineString
-        if (dataView.getUint32(offset, littleEndianLine) % 1000 !== 2) {
-            throw new Error('WKB: Inner geometries of MultiLineString not of type LineString');
-        }
-        offset += 4;
-        const parsed = parseLineString(dataView, offset, dimension, littleEndianLine);
-        offset = parsed.offset;
-        binaryLineGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
-}
-function parseMultiPolygon(dataView, offset, dimension, littleEndian) {
-    const nPolygons = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryPolygonGeometries = [];
-    for (let i = 0; i < nPolygons; i++) {
-        // Byte order for polygon
-        const littleEndianPolygon = dataView.getUint8(offset) === 1;
-        offset++;
-        // Assert type Polygon
-        if (dataView.getUint32(offset, littleEndianPolygon) % 1000 !== 3) {
-            throw new Error('WKB: Inner geometries of MultiPolygon not of type Polygon');
-        }
-        offset += 4;
-        const parsed = parsePolygon(dataView, 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 Uint32Array(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 Uint32Array(polygonIndices), size: 1 },
-        primitivePolygonIndices: { value: new Uint32Array(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;
-}