@loaders.gl/shapefile 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/lib/parsers/parse-shp.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSHPInBatches = exports.parseSHP = void 0;
+const binary_chunk_reader_1 = __importDefault(require("../streaming/binary-chunk-reader"));
+const parse_shp_header_1 = require("./parse-shp-header");
+const parse_shp_geometry_1 = require("./parse-shp-geometry");
+const LITTLE_ENDIAN = true;
+const BIG_ENDIAN = false;
+const SHP_HEADER_SIZE = 100;
+// According to the spec, the record header is just 8 bytes, but here we set it
+// to 12 so that we can also access the record's type
+const SHP_RECORD_HEADER_SIZE = 12;
+const STATE = {
+    EXPECTING_HEADER: 0,
+    EXPECTING_RECORD: 1,
+    END: 2,
+    ERROR: 3
+};
+class SHPParser {
+    constructor(options) {
+        this.options = {};
+        this.binaryReader = new binary_chunk_reader_1.default({ maxRewindBytes: SHP_RECORD_HEADER_SIZE });
+        this.state = STATE.EXPECTING_HEADER;
+        this.result = {
+            geometries: []
+        };
+        this.options = options;
+    }
+    write(arrayBuffer) {
+        this.binaryReader.write(arrayBuffer);
+        this.state = parseState(this.state, this.result, this.binaryReader, this.options);
+    }
+    end() {
+        this.binaryReader.end();
+        this.state = parseState(this.state, this.result, this.binaryReader, this.options);
+        // this.result.progress.bytesUsed = this.binaryReader.bytesUsed();
+        if (this.state !== STATE.END) {
+            this.state = STATE.ERROR;
+            this.result.error = 'SHP incomplete file';
+        }
+    }
+}
+function parseSHP(arrayBuffer, options) {
+    const shpParser = new SHPParser(options);
+    shpParser.write(arrayBuffer);
+    shpParser.end();
+    // @ts-ignore
+    return shpParser.result;
+}
+exports.parseSHP = parseSHP;
+/**
+ * @param asyncIterator
+ * @param options
+ * @returns
+ */
+async function* parseSHPInBatches(asyncIterator, options) {
+    const parser = new SHPParser(options);
+    let headerReturned = false;
+    for await (const arrayBuffer of asyncIterator) {
+        parser.write(arrayBuffer);
+        if (!headerReturned && parser.result.header) {
+            headerReturned = true;
+            yield parser.result.header;
+        }
+        if (parser.result.geometries.length > 0) {
+            yield parser.result.geometries;
+            parser.result.geometries = [];
+        }
+    }
+    parser.end();
+    if (parser.result.geometries.length > 0) {
+        yield parser.result.geometries;
+    }
+    return;
+}
+exports.parseSHPInBatches = parseSHPInBatches;
+/**
+ * State-machine parser for SHP data
+ *
+ * Note that whenever more data is needed, a `return`, not a `break`, is
+ * necessary, as the `break` keeps the context within `parseState`, while
+ * `return` releases context so that more data can be written into the
+ * BinaryChunkReader.
+ *
+ * @param  state Current state
+ * @param  result An object to hold result data
+ * @param  binaryReader
+ * @return State at end of current parsing
+ */
+/* eslint-disable complexity, max-depth */
+function parseState(state, result, binaryReader, options) {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        try {
+            switch (state) {
+                case STATE.ERROR:
+                case STATE.END:
+                    return state;
+                case STATE.EXPECTING_HEADER:
+                    // Parse initial file header
+                    const dataView = binaryReader.getDataView(SHP_HEADER_SIZE);
+                    if (!dataView) {
+                        return state;
+                    }
+                    result.header = (0, parse_shp_header_1.parseSHPHeader)(dataView);
+                    result.progress = {
+                        bytesUsed: 0,
+                        bytesTotal: result.header.length,
+                        rows: 0
+                    };
+                    // index numbering starts at 1
+                    result.currentIndex = 1;
+                    state = STATE.EXPECTING_RECORD;
+                    break;
+                case STATE.EXPECTING_RECORD:
+                    while (binaryReader.hasAvailableBytes(SHP_RECORD_HEADER_SIZE)) {
+                        const recordHeaderView = binaryReader.getDataView(SHP_RECORD_HEADER_SIZE);
+                        const recordHeader = {
+                            recordNumber: recordHeaderView.getInt32(0, BIG_ENDIAN),
+                            // 2 byte words; includes the four words of record header
+                            byteLength: recordHeaderView.getInt32(4, BIG_ENDIAN) * 2,
+                            // This is actually part of the record, not the header...
+                            type: recordHeaderView.getInt32(8, LITTLE_ENDIAN)
+                        };
+                        if (!binaryReader.hasAvailableBytes(recordHeader.byteLength - 4)) {
+                            binaryReader.rewind(SHP_RECORD_HEADER_SIZE);
+                            return state;
+                        }
+                        const invalidRecord = recordHeader.byteLength < 4 ||
+                            recordHeader.type !== result.header.type ||
+                            recordHeader.recordNumber !== result.currentIndex;
+                        // All records must have at least four bytes (for the record shape type)
+                        if (invalidRecord) {
+                            // Malformed record, try again, advancing just 4 bytes
+                            // Note: this is a rewind because binaryReader.getDataView above
+                            // moved the pointer forward 12 bytes, so rewinding 8 bytes still
+                            // leaves us 4 bytes ahead
+                            binaryReader.rewind(SHP_RECORD_HEADER_SIZE - 4);
+                        }
+                        else {
+                            // Note: type is actually part of the record, not the header, so
+                            // rewind 4 bytes before reading record
+                            binaryReader.rewind(4);
+                            const recordView = binaryReader.getDataView(recordHeader.byteLength);
+                            const geometry = (0, parse_shp_geometry_1.parseRecord)(recordView, options);
+                            result.geometries.push(geometry);
+                            result.currentIndex++;
+                            result.progress.rows = result.currentIndex - 1;
+                        }
+                    }
+                    if (binaryReader.ended) {
+                        state = STATE.END;
+                    }
+                    return state;
+                default:
+                    state = STATE.ERROR;
+                    result.error = `illegal parser state ${state}`;
+                    return state;
+            }
+        }
+        catch (error) {
+            state = STATE.ERROR;
+            result.error = `SHP parsing failed: ${error?.message}`;
+            return state;
+        }
+    }
+}

package/dist/lib/parsers/parse-shx.d.ts

@@ -0,0 +1,10 @@
+export interface SHXOutput {
+    offsets: Int32Array;
+    lengths: Int32Array;
+}
+/**
+ * @param arrayBuffer
+ * @returns SHXOutput
+ */
+export declare function parseShx(arrayBuffer: ArrayBuffer): SHXOutput;
+//# sourceMappingURL=parse-shx.d.ts.map

package/dist/lib/parsers/parse-shx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-shx.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-shx.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,UAAU,CAAC;IACpB,OAAO,EAAE,UAAU,CAAC;CACrB;AAKD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,WAAW,EAAE,WAAW,GAAG,SAAS,CAoB5D"}

package/dist/lib/parsers/parse-shx.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseShx = void 0;
+const parse_shp_header_1 = require("./parse-shp-header");
+const SHX_HEADER_SIZE = 100;
+const BIG_ENDIAN = false;
+/**
+ * @param arrayBuffer
+ * @returns SHXOutput
+ */
+function parseShx(arrayBuffer) {
+    // SHX header is identical to SHP Header
+    const headerView = new DataView(arrayBuffer, 0, SHX_HEADER_SIZE);
+    const header = (0, parse_shp_header_1.parseSHPHeader)(headerView);
+    const contentLength = header.length - SHX_HEADER_SIZE;
+    const contentView = new DataView(arrayBuffer, SHX_HEADER_SIZE, contentLength);
+    const offsets = new Int32Array(contentLength);
+    const lengths = new Int32Array(contentLength);
+    for (let i = 0; i < contentLength / 8; i++) {
+        offsets[i] = contentView.getInt32(i * 8, BIG_ENDIAN);
+        lengths[i] = contentView.getInt32(i * 8 + 4, BIG_ENDIAN);
+    }
+    return {
+        offsets,
+        lengths
+    };
+}
+exports.parseShx = parseShx;

package/dist/lib/streaming/binary-chunk-reader.d.ts

@@ -0,0 +1,59 @@
+export default class BinaryChunkReader {
+    offset: number;
+    arrayBuffers: ArrayBuffer[];
+    ended: boolean;
+    maxRewindBytes: number;
+    constructor(options?: {
+        [key: string]: any;
+    });
+    /**
+     * @param arrayBuffer
+     */
+    write(arrayBuffer: ArrayBuffer): void;
+    end(): void;
+    /**
+     * Has enough bytes available in array buffers
+     *
+     * @param bytes Number of bytes
+     * @return boolean
+     */
+    hasAvailableBytes(bytes: number): boolean;
+    /**
+     * Find offsets of byte ranges within this.arrayBuffers
+     *
+     * @param  bytes Byte length to read
+     * @return Arrays with byte ranges pointing to this.arrayBuffers, Output type is nested array, e.g. [ [0, [1, 2]], ...]
+     */
+    findBufferOffsets(bytes: number): any[] | null;
+    /**
+     * Get the required number of bytes from the iterator
+     *
+     * @param bytes Number of bytes
+     * @return DataView with data
+     */
+    getDataView(bytes: number): DataView | null;
+    /**
+     * Dispose of old array buffers
+     */
+    disposeBuffers(): void;
+    /**
+     * Copy multiple ArrayBuffers into one contiguous ArrayBuffer
+     *
+     * In contrast to concatenateArrayBuffers, this only copies the necessary
+     * portions of the source arrays, rather than first copying the entire arrays
+     * then taking a part of them.
+     *
+     * @param bufferOffsets List of internal array offsets
+     * @return New contiguous ArrayBuffer
+     */
+    _combineArrayBuffers(bufferOffsets: any[]): ArrayBufferLike;
+    /**
+     * @param bytes
+     */
+    skip(bytes: number): void;
+    /**
+     * @param bytes
+     */
+    rewind(bytes: number): void;
+}
+//# sourceMappingURL=binary-chunk-reader.d.ts.map

package/dist/lib/streaming/binary-chunk-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-chunk-reader.d.ts","sourceRoot":"","sources":["../../../src/lib/streaming/binary-chunk-reader.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,KAAK,EAAE,OAAO,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;gBAEX,OAAO,CAAC,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC;IAY1C;;OAEG;IACH,KAAK,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAIrC,GAAG,IAAI,IAAI;IAKX;;;;;OAKG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAWzC;;;;;OAKG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,EAAE,GAAG,IAAI;IAwC9C;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI;IA+B3C;;OAEG;IACH,cAAc,IAAI,IAAI;IAUtB;;;;;;;;;OASG;IACH,oBAAoB,CAAC,aAAa,EAAE,GAAG,EAAE,GAAG,eAAe;IAoB3D;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGzB;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAI5B"}

package/dist/lib/streaming/binary-chunk-reader.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BinaryChunkReader {
+    constructor(options) {
+        const { maxRewindBytes = 0 } = options || {};
+        /** current global offset into current array buffer*/
+        this.offset = 0;
+        /** current buffer from iterator */
+        this.arrayBuffers = [];
+        this.ended = false;
+        /** bytes behind offset to hold on to */
+        this.maxRewindBytes = maxRewindBytes;
+    }
+    /**
+     * @param arrayBuffer
+     */
+    write(arrayBuffer) {
+        this.arrayBuffers.push(arrayBuffer);
+    }
+    end() {
+        this.arrayBuffers = [];
+        this.ended = true;
+    }
+    /**
+     * Has enough bytes available in array buffers
+     *
+     * @param bytes Number of bytes
+     * @return boolean
+     */
+    hasAvailableBytes(bytes) {
+        let bytesAvailable = -this.offset;
+        for (const arrayBuffer of this.arrayBuffers) {
+            bytesAvailable += arrayBuffer.byteLength;
+            if (bytesAvailable >= bytes) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Find offsets of byte ranges within this.arrayBuffers
+     *
+     * @param  bytes Byte length to read
+     * @return Arrays with byte ranges pointing to this.arrayBuffers, Output type is nested array, e.g. [ [0, [1, 2]], ...]
+     */
+    findBufferOffsets(bytes) {
+        let offset = -this.offset;
+        const selectedBuffers = [];
+        for (let i = 0; i < this.arrayBuffers.length; i++) {
+            const buf = this.arrayBuffers[i];
+            // Current buffer isn't long enough to reach global offset
+            if (offset + buf.byteLength <= 0) {
+                offset += buf.byteLength;
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            // Find start/end offsets for this buffer
+            // When offset < 0, need to skip over Math.abs(offset) bytes
+            // When offset > 0, implies bytes in previous buffer, start at 0
+            const start = offset <= 0 ? Math.abs(offset) : 0;
+            let end;
+            // Length of requested bytes is contained in current buffer
+            if (start + bytes <= buf.byteLength) {
+                end = start + bytes;
+                selectedBuffers.push([i, [start, end]]);
+                return selectedBuffers;
+            }
+            // Will need to look into next buffer
+            end = buf.byteLength;
+            selectedBuffers.push([i, [start, end]]);
+            // Need to read fewer bytes in next iter
+            bytes -= buf.byteLength - start;
+            offset += buf.byteLength;
+        }
+        // Should only finish loop if exhausted all arrays
+        return null;
+    }
+    /**
+     * Get the required number of bytes from the iterator
+     *
+     * @param bytes Number of bytes
+     * @return DataView with data
+     */
+    getDataView(bytes) {
+        const bufferOffsets = this.findBufferOffsets(bytes);
+        // return `null` if not enough data, except if end() already called, in
+        // which case throw an error.
+        if (!bufferOffsets && this.ended) {
+            throw new Error('binary data exhausted');
+        }
+        if (!bufferOffsets) {
+            // @ts-ignore
+            return null;
+        }
+        // If only one arrayBuffer needed, return DataView directly
+        if (bufferOffsets.length === 1) {
+            const [bufferIndex, [start, end]] = bufferOffsets[0];
+            const arrayBuffer = this.arrayBuffers[bufferIndex];
+            const view = new DataView(arrayBuffer, start, end - start);
+            this.offset += bytes;
+            this.disposeBuffers();
+            return view;
+        }
+        // Concatenate portions of multiple ArrayBuffers
+        const view = new DataView(this._combineArrayBuffers(bufferOffsets));
+        this.offset += bytes;
+        this.disposeBuffers();
+        return view;
+    }
+    /**
+     * Dispose of old array buffers
+     */
+    disposeBuffers() {
+        while (this.arrayBuffers.length > 0 &&
+            this.offset - this.maxRewindBytes >= this.arrayBuffers[0].byteLength) {
+            this.offset -= this.arrayBuffers[0].byteLength;
+            this.arrayBuffers.shift();
+        }
+    }
+    /**
+     * Copy multiple ArrayBuffers into one contiguous ArrayBuffer
+     *
+     * In contrast to concatenateArrayBuffers, this only copies the necessary
+     * portions of the source arrays, rather than first copying the entire arrays
+     * then taking a part of them.
+     *
+     * @param bufferOffsets List of internal array offsets
+     * @return New contiguous ArrayBuffer
+     */
+    _combineArrayBuffers(bufferOffsets) {
+        let byteLength = 0;
+        for (const bufferOffset of bufferOffsets) {
+            const [start, end] = bufferOffset[1];
+            byteLength += end - start;
+        }
+        const result = new Uint8Array(byteLength);
+        // Copy the subarrays
+        let resultOffset = 0;
+        for (const bufferOffset of bufferOffsets) {
+            const [bufferIndex, [start, end]] = bufferOffset;
+            const sourceArray = new Uint8Array(this.arrayBuffers[bufferIndex]);
+            result.set(sourceArray.subarray(start, end), resultOffset);
+            resultOffset += end - start;
+        }
+        return result.buffer;
+    }
+    /**
+     * @param bytes
+     */
+    skip(bytes) {
+        this.offset += bytes;
+    }
+    /**
+     * @param bytes
+     */
+    rewind(bytes) {
+        // TODO - only works if offset is already set
+        this.offset -= bytes;
+    }
+}
+exports.default = BinaryChunkReader;

package/dist/lib/streaming/binary-reader.d.ts

@@ -0,0 +1,32 @@
+export default class BinaryReader {
+    offset: number;
+    arrayBuffer: ArrayBuffer;
+    constructor(arrayBuffer: ArrayBuffer);
+    /**
+     * Checks if there are available bytes in data
+     *
+     * @param bytes
+     * @returns boolean
+     */
+    hasAvailableBytes(bytes: number): boolean;
+    /**
+     * Get the required number of bytes from the iterator
+     *
+     * @param bytes
+     * @returns Dataview
+     */
+    getDataView(bytes: number): DataView;
+    /**
+     * Skipping
+     *
+     * @param bytes
+     */
+    skip(bytes: number): void;
+    /**
+     * Rewinding
+     *
+     * @param bytes
+     */
+    rewind(bytes: number): void;
+}
+//# sourceMappingURL=binary-reader.d.ts.map

package/dist/lib/streaming/binary-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-reader.d.ts","sourceRoot":"","sources":["../../../src/lib/streaming/binary-reader.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,WAAW,CAAC;gBAEb,WAAW,EAAE,WAAW;IAMpC;;;;;OAKG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIzC;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ;IAYpC;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIzB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAG5B"}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BinaryReader {
+    constructor(arrayBuffer) {
+        /** current global (stream) offset */
+        this.offset = 0;
+        /** current buffer from iterator */
+        this.arrayBuffer = arrayBuffer;
+    }
+    /**
+     * Checks if there are available bytes in data
+     *
+     * @param bytes
+     * @returns boolean
+     */
+    hasAvailableBytes(bytes) {
+        return this.arrayBuffer.byteLength - this.offset >= bytes;
+    }
+    /**
+     * Get the required number of bytes from the iterator
+     *
+     * @param bytes
+     * @returns Dataview
+     */
+    getDataView(bytes) {
+        if (bytes && !this.hasAvailableBytes(bytes)) {
+            throw new Error('binary data exhausted');
+        }
+        const dataView = bytes
+            ? new DataView(this.arrayBuffer, this.offset, bytes)
+            : new DataView(this.arrayBuffer, this.offset);
+        this.offset += bytes;
+        return dataView;
+    }
+    /**
+     * Skipping
+     *
+     * @param bytes
+     */
+    skip(bytes) {
+        this.offset += bytes;
+    }
+    /**
+     * Rewinding
+     *
+     * @param bytes
+     */
+    rewind(bytes) {
+        this.offset -= bytes;
+    }
+}
+exports.default = BinaryReader;

package/dist/lib/streaming/zip-batch-iterators.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Zip two iterators together
+ *
+ * @param iterator1
+ * @param iterator2
+ */
+export declare function zipBatchIterators(iterator1: AsyncIterator<any[]>, iterator2: AsyncIterator<any[]>): AsyncGenerator<number[][], void, unknown>;
+//# sourceMappingURL=zip-batch-iterators.d.ts.map

package/dist/lib/streaming/zip-batch-iterators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-batch-iterators.d.ts","sourceRoot":"","sources":["../../../src/lib/streaming/zip-batch-iterators.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAuB,iBAAiB,CACtC,SAAS,EAAE,aAAa,CAAC,GAAG,EAAE,CAAC,EAC/B,SAAS,EAAE,aAAa,CAAC,GAAG,EAAE,CAAC,GAC9B,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,CA8B3C"}

package/dist/lib/streaming/zip-batch-iterators.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipBatchIterators = void 0;
+/**
+ * Zip two iterators together
+ *
+ * @param iterator1
+ * @param iterator2
+ */
+async function* zipBatchIterators(iterator1, iterator2) {
+    let batch1 = [];
+    let batch2 = [];
+    let iterator1Done = false;
+    let iterator2Done = false;
+    // TODO - one could let all iterators flow at full speed using `Promise.race`
+    // however we might end up with a big temporary buffer
+    while (!iterator1Done && !iterator2Done) {
+        if (batch1.length === 0 && !iterator1Done) {
+            const { value, done } = await iterator1.next();
+            if (done) {
+                iterator1Done = true;
+            }
+            else {
+                batch1 = value;
+            }
+        }
+        else if (batch2.length === 0 && !iterator2Done) {
+            const { value, done } = await iterator2.next();
+            if (done) {
+                iterator2Done = true;
+            }
+            else {
+                batch2 = value;
+            }
+        }
+        const batch = extractBatch(batch1, batch2);
+        if (batch) {
+            yield batch;
+        }
+    }
+}
+exports.zipBatchIterators = zipBatchIterators;
+/**
+ * Extract batch of same length from two batches
+ *
+ * @param batch1
+ * @param batch2
+ * @return array | null
+ */
+function extractBatch(batch1, batch2) {
+    const batchLength = Math.min(batch1.length, batch2.length);
+    if (batchLength === 0) {
+        return null;
+    }
+    // Non interleaved arrays
+    const batch = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];
+    // Modify the 2 batches
+    batch1.splice(0, batchLength);
+    batch2.splice(0, batchLength);
+    return batch;
+}

package/dist/shapefile-loader.d.ts

@@ -0,0 +1,26 @@
+import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+import { parseShapefile, parseShapefileInBatches } from './lib/parsers/parse-shapefile';
+/**
+ * Shapefile loader
+ * @note Shapefile is multifile format and requires providing additional files
+ */
+export declare const ShapefileLoader: {
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    category: string;
+    extensions: string[];
+    mimeTypes: string[];
+    tests: ArrayBufferLike[];
+    options: {
+        shapefile: {};
+        shp: {
+            _maxDimensions: number;
+        };
+    };
+    parse: typeof parseShapefile;
+    parseInBatches: typeof parseShapefileInBatches;
+};
+export declare const _typecheckShapefileLoader: LoaderWithParser;
+//# sourceMappingURL=shapefile-loader.d.ts.map

package/dist/shapefile-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapefile-loader.d.ts","sourceRoot":"","sources":["../src/shapefile-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAE/D,OAAO,EAAC,cAAc,EAAE,uBAAuB,EAAC,MAAM,+BAA+B,CAAC;AAMtF;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAiB3B,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,gBAAkC,CAAC"}

package/dist/shapefile-loader.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckShapefileLoader = exports.ShapefileLoader = void 0;
+const shp_loader_1 = require("./shp-loader");
+const parse_shapefile_1 = require("./lib/parsers/parse-shapefile");
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+/**
+ * Shapefile loader
+ * @note Shapefile is multifile format and requires providing additional files
+ */
+exports.ShapefileLoader = {
+    name: 'Shapefile',
+    id: 'shapefile',
+    module: 'shapefile',
+    version: VERSION,
+    category: 'geometry',
+    extensions: ['shp'],
+    mimeTypes: ['application/octet-stream'],
+    tests: [new Uint8Array(shp_loader_1.SHP_MAGIC_NUMBER).buffer],
+    options: {
+        shapefile: {},
+        shp: {
+            _maxDimensions: 4
+        }
+    },
+    parse: parse_shapefile_1.parseShapefile,
+    parseInBatches: parse_shapefile_1.parseShapefileInBatches
+};
+exports._typecheckShapefileLoader = exports.ShapefileLoader;

package/dist/shp-loader.d.ts

@@ -0,0 +1,9 @@
+import type { Loader, LoaderWithParser } from '@loaders.gl/loader-utils';
+export declare const SHP_MAGIC_NUMBER: number[];
+/**
+ * SHP file loader
+ */
+export declare const SHPWorkerLoader: Loader;
+/** SHP file loader */
+export declare const SHPLoader: LoaderWithParser;
+//# sourceMappingURL=shp-loader.d.ts.map

package/dist/shp-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shp-loader.d.ts","sourceRoot":"","sources":["../src/shp-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAOvE,eAAO,MAAM,gBAAgB,UAA2B,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,MAgB7B,CAAC;AAEF,sBAAsB;AACtB,eAAO,MAAM,SAAS,EAAE,gBAKvB,CAAC"}