@loaders.gl/shapefile 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/dist.dev.js

@@ -2,14 +2,19 @@
   if (typeof exports === 'object' && typeof module === 'object')
     module.exports = factory();
   else if (typeof define === 'function' && define.amd) define([], factory);
-        else if (typeof exports === 'object') exports['loader'] = factory();
-  else root['loader'] = factory();})(globalThis, function () {
+        else if (typeof exports === 'object') exports['loaders'] = factory();
+  else root['loaders'] = factory();})(globalThis, function () {
 "use strict";
 var __exports__ = (() => {
+  var __create = Object.create;
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -22,11 +27,27 @@ var __exports__ = (() => {
     }
     return to;
   };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  // external-global-plugin:@loaders.gl/core
+  var require_core = __commonJS({
+    "external-global-plugin:@loaders.gl/core"(exports4, module) {
+      module.exports = globalThis.loaders;
+    }
+  });
+
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
     DBFLoader: () => DBFLoader,
     DBFWorkerLoader: () => DBFWorkerLoader,
     SHPLoader: () => SHPLoader,
@@ -36,18 +57,20 @@ var __exports__ = (() => {
     _BinaryReader: () => BinaryReader,
     _zipBatchIterators: () => zipBatchIterators
   });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // src/lib/streaming/binary-chunk-reader.ts
   var BinaryChunkReader = class {
     constructor(options) {
-      const {
-        maxRewindBytes = 0
-      } = options || {};
+      const { maxRewindBytes = 0 } = options || {};
       this.offset = 0;
       this.arrayBuffers = [];
       this.ended = false;
       this.maxRewindBytes = maxRewindBytes;
     }
+    /**
+     * @param arrayBuffer
+     */
     write(arrayBuffer) {
       this.arrayBuffers.push(arrayBuffer);
     }
@@ -55,6 +78,12 @@ var __exports__ = (() => {
       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) {
@@ -65,6 +94,12 @@ var __exports__ = (() => {
       }
       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 = [];
@@ -88,6 +123,12 @@ var __exports__ = (() => {
       }
       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);
       if (!bufferOffsets && this.ended) {
@@ -109,12 +150,25 @@ var __exports__ = (() => {
       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) {
@@ -131,9 +185,15 @@ var __exports__ = (() => {
       }
       return result.buffer;
     }
+    /**
+     * @param bytes
+     */
     skip(bytes) {
       this.offset += bytes;
     }
+    /**
+     * @param bytes
+     */
     rewind(bytes) {
       this.offset -= bytes;
     }
@@ -146,6 +206,7 @@ var __exports__ = (() => {
   function parseSHPHeader(headerView) {
     const header = {
       magic: headerView.getInt32(0, BIG_ENDIAN),
+      // Length is stored as # of 2-byte words; multiply by 2 to get # of bytes
       length: headerView.getInt32(24, BIG_ENDIAN) * 2,
       version: headerView.getInt32(28, LITTLE_ENDIAN),
       type: headerView.getInt32(32, LITTLE_ENDIAN),
@@ -172,9 +233,7 @@ var __exports__ = (() => {
   // src/lib/parsers/parse-shp-geometry.ts
   var LITTLE_ENDIAN2 = true;
   function parseRecord(view, options) {
-    const {
-      _maxDimensions = 4
-    } = options?.shp || {};
+    const { _maxDimensions = 4 } = options?.shp || {};
     let offset = 0;
     const type = view.getInt32(offset, LITTLE_ENDIAN2);
     offset += Int32Array.BYTES_PER_ELEMENT;
@@ -216,10 +275,7 @@ var __exports__ = (() => {
     let positions;
     [positions, offset] = parsePositions(view, offset, 1, dim);
     return {
-      positions: {
-        value: positions,
-        size: dim
-      },
+      positions: { value: positions, size: dim },
       type: "Point"
     };
   }
@@ -241,10 +297,7 @@ var __exports__ = (() => {
     }
     const positions = concatPositions(xyPositions, mPositions, zPositions);
     return {
-      positions: {
-        value: positions,
-        size: dim
-      },
+      positions: { value: positions, size: dim },
       type: "Point"
     };
   }
@@ -276,14 +329,8 @@ var __exports__ = (() => {
     if (type === "LineString") {
       return {
         type,
-        positions: {
-          value: positions,
-          size: dim
-        },
-        pathIndices: {
-          value: ringIndices,
-          size: 1
-        }
+        positions: { value: positions, size: dim },
+        pathIndices: { value: ringIndices, size: 1 }
       };
     }
     const polygonIndices = [];
@@ -299,24 +346,22 @@ var __exports__ = (() => {
     polygonIndices.push(nPoints);
     return {
       type,
-      positions: {
-        value: positions,
-        size: dim
-      },
-      primitivePolygonIndices: {
-        value: ringIndices,
-        size: 1
-      },
-      polygonIndices: {
-        value: new Uint32Array(polygonIndices),
-        size: 1
-      }
+      positions: { value: positions, size: dim },
+      primitivePolygonIndices: { value: ringIndices, size: 1 },
+      // TODO: Dynamically choose Uint32Array over Uint16Array only when
+      // necessary. I believe the implementation requires nPoints to be the
+      // largest value in the array, so you should be able to use Uint32Array only
+      // when nPoints > 65535.
+      polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 }
     };
   }
   function parsePositions(view, offset, nPoints, dim) {
     const bufferOffset = view.byteOffset + offset;
     const bufferLength = nPoints * dim * Float64Array.BYTES_PER_ELEMENT;
-    return [new Float64Array(view.buffer.slice(bufferOffset, bufferOffset + bufferLength)), offset + bufferLength];
+    return [
+      new Float64Array(view.buffer.slice(bufferOffset, bufferOffset + bufferLength)),
+      offset + bufferLength
+    ];
   }
   function concatPositions(xyPositions, mPositions, zPositions) {
     if (!(mPositions || zPositions)) {
@@ -373,21 +418,21 @@ var __exports__ = (() => {
     ERROR: 3
   };
   var SHPParser = class {
-    options = {};
-    binaryReader = new BinaryChunkReader({
-      maxRewindBytes: SHP_RECORD_HEADER_SIZE
-    });
-    state = STATE.EXPECTING_HEADER;
-    result = {
-      geometries: [],
-      progress: {
-        bytesTotal: NaN,
-        bytesUsed: NaN,
-        rows: NaN
-      },
-      currentIndex: NaN
-    };
     constructor(options) {
+      this.options = {};
+      this.binaryReader = new BinaryChunkReader({ maxRewindBytes: SHP_RECORD_HEADER_SIZE });
+      this.state = STATE.EXPECTING_HEADER;
+      this.result = {
+        geometries: [],
+        // Initialize with number values to make TS happy
+        // These are initialized for real in STATE.EXPECTING_HEADER
+        progress: {
+          bytesTotal: NaN,
+          bytesUsed: NaN,
+          rows: NaN
+        },
+        currentIndex: NaN
+      };
       this.options = options;
     }
     write(arrayBuffer) {
@@ -455,7 +500,9 @@ var __exports__ = (() => {
               const recordHeaderView = binaryReader.getDataView(SHP_RECORD_HEADER_SIZE);
               const recordHeader = {
                 recordNumber: recordHeaderView.getInt32(0, BIG_ENDIAN2),
+                // 2 byte words; includes the four words of record header
                 byteLength: recordHeaderView.getInt32(4, BIG_ENDIAN2) * 2,
+                // This is actually part of the record, not the header...
                 type: recordHeaderView.getInt32(8, LITTLE_ENDIAN3)
               };
               if (!binaryReader.hasAvailableBytes(recordHeader.byteLength - 4)) {
@@ -492,7 +539,7 @@ var __exports__ = (() => {
   }
 
   // src/shp-loader.ts
-  var VERSION = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var SHP_MAGIC_NUMBER2 = [0, 0, 39, 10];
   var SHPWorkerLoader = {
     name: "SHP",
@@ -503,6 +550,7 @@ var __exports__ = (() => {
     category: "geometry",
     extensions: ["shp"],
     mimeTypes: ["application/octet-stream"],
+    // ISSUE: This also identifies SHX files, which are identical to SHP for the first 100 bytes...
     tests: [new Uint8Array(SHP_MAGIC_NUMBER2).buffer],
     options: {
       shp: {
@@ -589,11 +637,11 @@ var __exports__ = (() => {
     }
   }
   function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    const {
-      positions
-    } = data;
+    const { positions } = data;
     const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter(
+      (x) => x >= startIndex && x <= endIndex
+    );
     const multi = polygonIndices.length > 2;
     if (!multi) {
       const coordinates2 = [];
@@ -603,62 +651,44 @@ var __exports__ = (() => {
         const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
         coordinates2.push(ringCoordinates);
       }
-      return {
-        type: "Polygon",
-        coordinates: coordinates2
-      };
+      return { type: "Polygon", coordinates: coordinates2 };
     }
     const coordinates = [];
     for (let i = 0; i < polygonIndices.length - 1; i++) {
       const startPolygonIndex = polygonIndices[i];
       const endPolygonIndex = polygonIndices[i + 1];
-      const polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
+      const polygonCoordinates = polygonToGeoJson(
+        data,
+        startPolygonIndex,
+        endPolygonIndex
+      ).coordinates;
       coordinates.push(polygonCoordinates);
     }
-    return {
-      type: "MultiPolygon",
-      coordinates
-    };
+    return { type: "MultiPolygon", coordinates };
   }
   function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    const {
-      positions
-    } = data;
+    const { positions } = data;
     const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
     const multi = pathIndices.length > 2;
     if (!multi) {
       const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
-      return {
-        type: "LineString",
-        coordinates: coordinates2
-      };
+      return { type: "LineString", coordinates: coordinates2 };
     }
     const coordinates = [];
     for (let i = 0; i < pathIndices.length - 1; i++) {
       const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
       coordinates.push(ringCoordinates);
     }
-    return {
-      type: "MultiLineString",
-      coordinates
-    };
+    return { type: "MultiLineString", coordinates };
   }
   function pointToGeoJson(data, startIndex, endIndex) {
-    const {
-      positions
-    } = data;
+    const { positions } = data;
     const coordinates = ringToGeoJson(positions, startIndex, endIndex);
     const multi = coordinates.length > 1;
     if (multi) {
-      return {
-        type: "MultiPoint",
-        coordinates
-      };
+      return { type: "MultiPoint", coordinates };
     }
-    return {
-      type: "Point",
-      coordinates: coordinates[0]
-    };
+    return { type: "Point", coordinates: coordinates[0] };
   }
   function ringToGeoJson(positions, startIndex, endIndex) {
     startIndex = startIndex || 0;
@@ -6072,10 +6102,7 @@ var __exports__ = (() => {
     let iterator2Done = false;
     while (!iterator1Done && !iterator2Done) {
       if (batch1Data.length === 0 && !iterator1Done) {
-        const {
-          value,
-          done
-        } = await iterator1.next();
+        const { value, done } = await iterator1.next();
         if (done) {
           iterator1Done = true;
         } else {
@@ -6083,10 +6110,7 @@ var __exports__ = (() => {
         }
       }
       if (batch2Data.length === 0 && !iterator2Done) {
-        const {
-          value,
-          done
-        } = await iterator2.next();
+        const { value, done } = await iterator2.next();
         if (done) {
           iterator2Done = true;
         } else {
@@ -6118,23 +6142,18 @@ var __exports__ = (() => {
   // src/lib/parsers/parse-dbf.ts
   var LITTLE_ENDIAN4 = true;
   var DBF_HEADER_SIZE = 32;
-  var STATE2 = function(STATE3) {
-    STATE3[STATE3["START"] = 0] = "START";
-    STATE3[STATE3["FIELD_DESCRIPTORS"] = 1] = "FIELD_DESCRIPTORS";
-    STATE3[STATE3["FIELD_PROPERTIES"] = 2] = "FIELD_PROPERTIES";
-    STATE3[STATE3["END"] = 3] = "END";
-    STATE3[STATE3["ERROR"] = 4] = "ERROR";
-    return STATE3;
-  }(STATE2 || {});
   var DBFParser = class {
-    binaryReader = new BinaryChunkReader();
-    state = STATE2.START;
-    result = {
-      data: []
-    };
     constructor(options) {
+      this.binaryReader = new BinaryChunkReader();
+      this.state = 0 /* START */;
+      this.result = {
+        data: []
+      };
       this.textDecoder = new TextDecoder(options.encoding);
     }
+    /**
+     * @param arrayBuffer
+     */
     write(arrayBuffer) {
       this.binaryReader.write(arrayBuffer);
       this.state = parseState2(this.state, this.result, this.binaryReader, this.textDecoder);
@@ -6142,25 +6161,18 @@ var __exports__ = (() => {
     end() {
       this.binaryReader.end();
       this.state = parseState2(this.state, this.result, this.binaryReader, this.textDecoder);
-      if (this.state !== STATE2.END) {
-        this.state = STATE2.ERROR;
+      if (this.state !== 3 /* END */) {
+        this.state = 4 /* ERROR */;
         this.result.error = "DBF incomplete file";
       }
     }
   };
   function parseDBF(arrayBuffer, options = {}) {
-    const {
-      encoding = "latin1"
-    } = options.dbf || {};
-    const dbfParser = new DBFParser({
-      encoding
-    });
+    const { encoding = "latin1" } = options.dbf || {};
+    const dbfParser = new DBFParser({ encoding });
     dbfParser.write(arrayBuffer);
     dbfParser.end();
-    const {
-      data,
-      schema
-    } = dbfParser.result;
+    const { data, schema } = dbfParser.result;
     const shape = options?.dbf?.shape;
     switch (shape) {
       case "object-row-table": {
@@ -6172,22 +6184,15 @@ var __exports__ = (() => {
         return table;
       }
       case "table":
-        return {
-          schema,
-          rows: data
-        };
+        return { schema, rows: data };
       case "rows":
       default:
         return data;
     }
   }
   async function* parseDBFInBatches(asyncIterator, options = {}) {
-    const {
-      encoding = "latin1"
-    } = options.dbf || {};
-    const parser = new DBFParser({
-      encoding
-    });
+    const { encoding = "latin1" } = options.dbf || {};
+    const parser = new DBFParser({ encoding });
     let headerReturned = false;
     for await (const arrayBuffer of asyncIterator) {
       parser.write(arrayBuffer);
@@ -6209,10 +6214,10 @@ var __exports__ = (() => {
     while (true) {
       try {
         switch (state) {
-          case STATE2.ERROR:
-          case STATE2.END:
+          case 4 /* ERROR */:
+          case 3 /* END */:
             return state;
-          case STATE2.START:
+          case 0 /* START */:
             const dataView = binaryReader.getDataView(DBF_HEADER_SIZE);
             if (!dataView) {
               return state;
@@ -6223,10 +6228,13 @@ var __exports__ = (() => {
               rowsTotal: result.dbfHeader.nRecords,
               rows: 0
             };
-            state = STATE2.FIELD_DESCRIPTORS;
+            state = 1 /* FIELD_DESCRIPTORS */;
             break;
-          case STATE2.FIELD_DESCRIPTORS:
-            const fieldDescriptorView = binaryReader.getDataView(result.dbfHeader.headerLength - DBF_HEADER_SIZE);
+          case 1 /* FIELD_DESCRIPTORS */:
+            const fieldDescriptorView = binaryReader.getDataView(
+              // @ts-ignore
+              result.dbfHeader.headerLength - DBF_HEADER_SIZE
+            );
             if (!fieldDescriptorView) {
               return state;
             }
@@ -6235,14 +6243,11 @@ var __exports__ = (() => {
               fields: result.dbfFields.map((dbfField) => makeField(dbfField)),
               metadata: {}
             };
-            state = STATE2.FIELD_PROPERTIES;
+            state = 2 /* FIELD_PROPERTIES */;
             binaryReader.skip(1);
             break;
-          case STATE2.FIELD_PROPERTIES:
-            const {
-              recordLength = 0,
-              nRecords = 0
-            } = result?.dbfHeader || {};
+          case 2 /* FIELD_PROPERTIES */:
+            const { recordLength = 0, nRecords = 0 } = result?.dbfHeader || {};
             while (result.data.length < nRecords) {
               const recordView = binaryReader.getDataView(recordLength - 1);
               if (!recordView) {
@@ -6253,15 +6258,15 @@ var __exports__ = (() => {
               result.data.push(row);
               result.progress.rows = result.data.length;
             }
-            state = STATE2.END;
+            state = 3 /* END */;
             break;
           default:
-            state = STATE2.ERROR;
+            state = 4 /* ERROR */;
             result.error = `illegal parser state ${state}`;
             return state;
         }
       } catch (error) {
-        state = STATE2.ERROR;
+        state = 4 /* ERROR */;
         result.error = `DBF parsing failed: ${error.message}`;
         return state;
       }
@@ -6269,12 +6274,17 @@ var __exports__ = (() => {
   }
   function parseDBFHeader(headerView) {
     return {
+      // Last updated date
       year: headerView.getUint8(1) + 1900,
       month: headerView.getUint8(2),
       day: headerView.getUint8(3),
+      // Number of records in data file
       nRecords: headerView.getUint32(4, LITTLE_ENDIAN4),
+      // Length of header in bytes
       headerLength: headerView.getUint16(8, LITTLE_ENDIAN4),
+      // Length of each record
       recordLength: headerView.getUint16(10, LITTLE_ENDIAN4),
+      // Not sure if this is usually set
       languageDriver: headerView.getUint8(29)
     };
   }
@@ -6298,7 +6308,9 @@ var __exports__ = (() => {
     const out = {};
     let offset = 0;
     for (const field of fields) {
-      const text = textDecoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset, field.fieldLength));
+      const text = textDecoder.decode(
+        new Uint8Array(view.buffer, view.byteOffset + offset, field.fieldLength)
+      );
       out[field.name] = parseField(text, field.dataType);
       offset += field.fieldLength;
     }
@@ -6337,69 +6349,29 @@ var __exports__ = (() => {
   function parseCharacter(text) {
     return text.trim() || null;
   }
-  function makeField({
-    name,
-    dataType,
-    fieldLength,
-    decimal
-  }) {
+  function makeField({ name, dataType, fieldLength, decimal }) {
     switch (dataType) {
       case "B":
-        return {
-          name,
-          type: "float64",
-          nullable: true,
-          metadata: {}
-        };
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "C":
-        return {
-          name,
-          type: "utf8",
-          nullable: true,
-          metadata: {}
-        };
+        return { name, type: "utf8", nullable: true, metadata: {} };
       case "F":
-        return {
-          name,
-          type: "float64",
-          nullable: true,
-          metadata: {}
-        };
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "N":
-        return {
-          name,
-          type: "float64",
-          nullable: true,
-          metadata: {}
-        };
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "O":
-        return {
-          name,
-          type: "float64",
-          nullable: true,
-          metadata: {}
-        };
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "D":
-        return {
-          name,
-          type: "timestamp-millisecond",
-          nullable: true,
-          metadata: {}
-        };
+        return { name, type: "timestamp-millisecond", nullable: true, metadata: {} };
       case "L":
-        return {
-          name,
-          type: "bool",
-          nullable: true,
-          metadata: {}
-        };
+        return { name, type: "bool", nullable: true, metadata: {} };
       default:
         throw new Error("Unsupported data type");
     }
   }
 
   // src/dbf-loader.ts
-  var VERSION2 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var DBFWorkerLoader = {
     name: "DBF",
     id: "dbf",
@@ -6426,26 +6398,27 @@ var __exports__ = (() => {
 
   // src/lib/parsers/parse-shapefile.ts
   async function* parseShapefileInBatches(asyncIterator, options, context) {
-    const {
-      reproject = false,
-      _targetCrs = "WGS84"
-    } = options?.gis || {};
-    const {
-      shx,
-      cpg,
-      prj
-    } = await loadShapefileSidecarFiles(options, context);
-    const shapeIterable = await parseInBatchesFromContext(asyncIterator, SHPLoader, options, context);
+    const { reproject = false, _targetCrs = "WGS84" } = options?.gis || {};
+    const { shx, cpg, prj } = await loadShapefileSidecarFiles(options, context);
+    const shapeIterable = await parseInBatchesFromContext(
+      asyncIterator,
+      SHPLoader,
+      options,
+      context
+    );
     const shapeIterator = shapeIterable[Symbol.asyncIterator]?.() || shapeIterable[Symbol.iterator]?.();
     let propertyIterator = null;
     const dbfResponse = await context?.fetch(replaceExtension(context?.url || "", "dbf"));
     if (dbfResponse?.ok) {
-      const propertyIterable = await parseInBatchesFromContext(dbfResponse, DBFLoader, {
-        ...options,
-        dbf: {
-          encoding: cpg || "latin1"
-        }
-      }, context);
+      const propertyIterable = await parseInBatchesFromContext(
+        dbfResponse,
+        DBFLoader,
+        {
+          ...options,
+          dbf: { encoding: cpg || "latin1" }
+        },
+        context
+      );
       propertyIterator = propertyIterable[Symbol.asyncIterator]?.() || propertyIterable[Symbol.iterator]();
     }
     let shapeHeader = (await shapeIterator.next()).value;
@@ -6488,29 +6461,19 @@ var __exports__ = (() => {
     }
   }
   async function parseShapefile(arrayBuffer, options, context) {
-    const {
-      reproject = false,
-      _targetCrs = "WGS84"
-    } = options?.gis || {};
-    const {
-      shx,
-      cpg,
-      prj
-    } = await loadShapefileSidecarFiles(options, context);
-    const {
-      header,
-      geometries
-    } = await parseFromContext(arrayBuffer, SHPLoader, options, context);
+    const { reproject = false, _targetCrs = "WGS84" } = options?.gis || {};
+    const { shx, cpg, prj } = await loadShapefileSidecarFiles(options, context);
+    const { header, geometries } = await parseFromContext(arrayBuffer, SHPLoader, options, context);
     const geojsonGeometries = parseGeometries(geometries);
     let propertyTable;
     const dbfResponse = await context?.fetch(replaceExtension(context?.url, "dbf"));
     if (dbfResponse?.ok) {
-      propertyTable = await parseFromContext(dbfResponse, DBFLoader, {
-        dbf: {
-          shape: "object-row-table",
-          encoding: cpg || "latin1"
-        }
-      }, context);
+      propertyTable = await parseFromContext(
+        dbfResponse,
+        DBFLoader,
+        { dbf: { shape: "object-row-table", encoding: cpg || "latin1" } },
+        context
+      );
     }
     let features = joinProperties(geojsonGeometries, propertyTable?.data || []);
     if (reproject) {
@@ -6519,13 +6482,11 @@ var __exports__ = (() => {
     switch (options?.shapefile?.shape) {
       case "geojson-table":
         return {
+          // @ts-expect-error
           shape: "geojson-table",
           type: "FeatureCollection",
           encoding: cpg,
-          schema: propertyTable?.schema || {
-            metadata: {},
-            fields: []
-          },
+          schema: propertyTable?.schema || { metadata: {}, fields: [] },
           prj,
           shx,
           header,
@@ -6555,6 +6516,7 @@ var __exports__ = (() => {
       const feature = {
         type: "Feature",
         geometry,
+        // properties can be undefined if dbfResponse above was empty
         properties: properties && properties[i] || {}
       };
       features.push(feature);
@@ -6565,17 +6527,11 @@ var __exports__ = (() => {
     if (!sourceCrs && !targetCrs) {
       return features;
     }
-    const projection = new Proj4Projection({
-      from: sourceCrs || "WGS84",
-      to: targetCrs || "WGS84"
-    });
+    const projection = new Proj4Projection({ from: sourceCrs || "WGS84", to: targetCrs || "WGS84" });
     return transformGeoJsonCoords(features, (coord) => projection.project(coord));
   }
   async function loadShapefileSidecarFiles(options, context) {
-    const {
-      url,
-      fetch
-    } = context;
+    const { url, fetch } = context;
     const shxPromise = fetch(replaceExtension(url, "shx"));
     const cpgPromise = fetch(replaceExtension(url, "cpg"));
     const prjPromise = fetch(replaceExtension(url, "prj"));
@@ -6627,7 +6583,7 @@ var __exports__ = (() => {
   }
 
   // src/shapefile-loader.ts
-  var VERSION3 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var ShapefileLoader = {
     name: "Shapefile",
     id: "shapefile",
@@ -6645,7 +6601,9 @@ var __exports__ = (() => {
         _maxDimensions: 4
       }
     },
+    // @ts-expect-error
     parse: parseShapefile,
+    // @ts-expect-error
     parseInBatches: parseShapefileInBatches
   };
 
@@ -6655,9 +6613,21 @@ var __exports__ = (() => {
       this.offset = 0;
       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");
@@ -6666,14 +6636,24 @@ var __exports__ = (() => {
       this.offset += bytes;
       return dataView;
     }
+    /**
+     * Skipping
+     *
+     * @param bytes
+     */
     skip(bytes) {
       this.offset += bytes;
     }
+    /**
+     * Rewinding
+     *
+     * @param bytes
+     */
     rewind(bytes) {
       this.offset -= bytes;
     }
   };
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
       return __exports__;
       });