@loaders.gl/shapefile 3.1.0-beta.5 → 3.1.2

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

@@ -7,139 +7,212 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-class BinaryChunkReader {
-  constructor(options) {
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var BinaryChunkReader = function () {
+  function BinaryChunkReader(options) {
+    (0, _classCallCheck2.default)(this, BinaryChunkReader);
     (0, _defineProperty2.default)(this, "offset", void 0);
     (0, _defineProperty2.default)(this, "arrayBuffers", void 0);
     (0, _defineProperty2.default)(this, "ended", void 0);
     (0, _defineProperty2.default)(this, "maxRewindBytes", void 0);
-    const {
-      maxRewindBytes = 0
-    } = options || {};
+
+    var _ref = options || {},
+        _ref$maxRewindBytes = _ref.maxRewindBytes,
+        maxRewindBytes = _ref$maxRewindBytes === void 0 ? 0 : _ref$maxRewindBytes;
+
     this.offset = 0;
     this.arrayBuffers = [];
     this.ended = false;
     this.maxRewindBytes = maxRewindBytes;
   }
 
-  write(arrayBuffer) {
-    this.arrayBuffers.push(arrayBuffer);
-  }
-
-  end() {
-    this.arrayBuffers = [];
-    this.ended = true;
-  }
-
-  hasAvailableBytes(bytes) {
-    let bytesAvailable = -this.offset;
-
-    for (const arrayBuffer of this.arrayBuffers) {
-      bytesAvailable += arrayBuffer.byteLength;
-
-      if (bytesAvailable >= bytes) {
-        return true;
-      }
+  (0, _createClass2.default)(BinaryChunkReader, [{
+    key: "write",
+    value: function write(arrayBuffer) {
+      this.arrayBuffers.push(arrayBuffer);
     }
+  }, {
+    key: "end",
+    value: function end() {
+      this.arrayBuffers = [];
+      this.ended = true;
+    }
+  }, {
+    key: "hasAvailableBytes",
+    value: function hasAvailableBytes(bytes) {
+      var bytesAvailable = -this.offset;
+
+      var _iterator = _createForOfIteratorHelper(this.arrayBuffers),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var arrayBuffer = _step.value;
+          bytesAvailable += arrayBuffer.byteLength;
+
+          if (bytesAvailable >= bytes) {
+            return true;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
 
-    return false;
-  }
-
-  findBufferOffsets(bytes) {
-    let offset = -this.offset;
-    const selectedBuffers = [];
-
-    for (let i = 0; i < this.arrayBuffers.length; i++) {
-      const buf = this.arrayBuffers[i];
-
-      if (offset + buf.byteLength <= 0) {
+      return false;
+    }
+  }, {
+    key: "findBufferOffsets",
+    value: function findBufferOffsets(bytes) {
+      var offset = -this.offset;
+      var selectedBuffers = [];
+
+      for (var i = 0; i < this.arrayBuffers.length; i++) {
+        var buf = this.arrayBuffers[i];
+
+        if (offset + buf.byteLength <= 0) {
+          offset += buf.byteLength;
+          continue;
+        }
+
+        var start = offset <= 0 ? Math.abs(offset) : 0;
+        var end = void 0;
+
+        if (start + bytes <= buf.byteLength) {
+          end = start + bytes;
+          selectedBuffers.push([i, [start, end]]);
+          return selectedBuffers;
+        }
+
+        end = buf.byteLength;
+        selectedBuffers.push([i, [start, end]]);
+        bytes -= buf.byteLength - start;
         offset += buf.byteLength;
-        continue;
       }
 
-      const start = offset <= 0 ? Math.abs(offset) : 0;
-      let end;
+      return null;
+    }
+  }, {
+    key: "getDataView",
+    value: function getDataView(bytes) {
+      var bufferOffsets = this.findBufferOffsets(bytes);
 
-      if (start + bytes <= buf.byteLength) {
-        end = start + bytes;
-        selectedBuffers.push([i, [start, end]]);
-        return selectedBuffers;
+      if (!bufferOffsets && this.ended) {
+        throw new Error('binary data exhausted');
       }
 
-      end = buf.byteLength;
-      selectedBuffers.push([i, [start, end]]);
-      bytes -= buf.byteLength - start;
-      offset += buf.byteLength;
-    }
+      if (!bufferOffsets) {
+        return null;
+      }
 
-    return null;
-  }
+      if (bufferOffsets.length === 1) {
+        var _bufferOffsets$ = (0, _slicedToArray2.default)(bufferOffsets[0], 2),
+            bufferIndex = _bufferOffsets$[0],
+            _bufferOffsets$$ = (0, _slicedToArray2.default)(_bufferOffsets$[1], 2),
+            start = _bufferOffsets$$[0],
+            end = _bufferOffsets$$[1];
 
-  getDataView(bytes) {
-    const bufferOffsets = this.findBufferOffsets(bytes);
+        var arrayBuffer = this.arrayBuffers[bufferIndex];
 
-    if (!bufferOffsets && this.ended) {
-      throw new Error('binary data exhausted');
-    }
+        var _view = new DataView(arrayBuffer, start, end - start);
 
-    if (!bufferOffsets) {
-      return null;
-    }
+        this.offset += bytes;
+        this.disposeBuffers();
+        return _view;
+      }
 
-    if (bufferOffsets.length === 1) {
-      const [bufferIndex, [start, end]] = bufferOffsets[0];
-      const arrayBuffer = this.arrayBuffers[bufferIndex];
-      const view = new DataView(arrayBuffer, start, end - start);
+      var view = new DataView(this._combineArrayBuffers(bufferOffsets));
       this.offset += bytes;
       this.disposeBuffers();
       return view;
     }
-
-    const view = new DataView(this._combineArrayBuffers(bufferOffsets));
-    this.offset += bytes;
-    this.disposeBuffers();
-    return view;
-  }
-
-  disposeBuffers() {
-    while (this.arrayBuffers.length > 0 && this.offset - this.maxRewindBytes >= this.arrayBuffers[0].byteLength) {
-      this.offset -= this.arrayBuffers[0].byteLength;
-      this.arrayBuffers.shift();
+  }, {
+    key: "disposeBuffers",
+    value: function disposeBuffers() {
+      while (this.arrayBuffers.length > 0 && this.offset - this.maxRewindBytes >= this.arrayBuffers[0].byteLength) {
+        this.offset -= this.arrayBuffers[0].byteLength;
+        this.arrayBuffers.shift();
+      }
     }
-  }
+  }, {
+    key: "_combineArrayBuffers",
+    value: function _combineArrayBuffers(bufferOffsets) {
+      var byteLength = 0;
+
+      var _iterator2 = _createForOfIteratorHelper(bufferOffsets),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var bufferOffset = _step2.value;
+
+          var _bufferOffset$ = (0, _slicedToArray2.default)(bufferOffset[1], 2),
+              start = _bufferOffset$[0],
+              end = _bufferOffset$[1];
+
+          byteLength += end - start;
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
 
-  _combineArrayBuffers(bufferOffsets) {
-    let byteLength = 0;
+      var result = new Uint8Array(byteLength);
+      var resultOffset = 0;
+
+      var _iterator3 = _createForOfIteratorHelper(bufferOffsets),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _bufferOffset = _step3.value;
+
+          var _bufferOffset2 = (0, _slicedToArray2.default)(_bufferOffset, 2),
+              bufferIndex = _bufferOffset2[0],
+              _bufferOffset2$ = (0, _slicedToArray2.default)(_bufferOffset2[1], 2),
+              _start = _bufferOffset2$[0],
+              _end = _bufferOffset2$[1];
+
+          var sourceArray = new Uint8Array(this.arrayBuffers[bufferIndex]);
+          result.set(sourceArray.subarray(_start, _end), resultOffset);
+          resultOffset += _end - _start;
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
 
-    for (const bufferOffset of bufferOffsets) {
-      const [start, end] = bufferOffset[1];
-      byteLength += end - start;
+      return result.buffer;
     }
-
-    const result = new Uint8Array(byteLength);
-    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;
+  }, {
+    key: "skip",
+    value: function skip(bytes) {
+      this.offset += bytes;
     }
-
-    return result.buffer;
-  }
-
-  skip(bytes) {
-    this.offset += bytes;
-  }
-
-  rewind(bytes) {
-    this.offset -= bytes;
-  }
-
-}
+  }, {
+    key: "rewind",
+    value: function rewind(bytes) {
+      this.offset -= bytes;
+    }
+  }]);
+  return BinaryChunkReader;
+}();
 
 exports.default = BinaryChunkReader;
 //# sourceMappingURL=binary-chunk-reader.js.map

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

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

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

@@ -7,39 +7,50 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-class BinaryReader {
-  constructor(arrayBuffer) {
+var BinaryReader = function () {
+  function BinaryReader(arrayBuffer) {
+    (0, _classCallCheck2.default)(this, BinaryReader);
     (0, _defineProperty2.default)(this, "offset", void 0);
     (0, _defineProperty2.default)(this, "arrayBuffer", void 0);
     this.offset = 0;
     this.arrayBuffer = arrayBuffer;
   }
 
-  hasAvailableBytes(bytes) {
-    return this.arrayBuffer.byteLength - this.offset >= bytes;
-  }
-
-  getDataView(bytes) {
-    if (bytes && !this.hasAvailableBytes(bytes)) {
-      throw new Error('binary data exhausted');
+  (0, _createClass2.default)(BinaryReader, [{
+    key: "hasAvailableBytes",
+    value: function hasAvailableBytes(bytes) {
+      return this.arrayBuffer.byteLength - this.offset >= bytes;
     }
-
-    const dataView = bytes ? new DataView(this.arrayBuffer, this.offset, bytes) : new DataView(this.arrayBuffer, this.offset);
-    this.offset += bytes;
-    return dataView;
-  }
-
-  skip(bytes) {
-    this.offset += bytes;
-  }
-
-  rewind(bytes) {
-    this.offset -= bytes;
-  }
-
-}
+  }, {
+    key: "getDataView",
+    value: function getDataView(bytes) {
+      if (bytes && !this.hasAvailableBytes(bytes)) {
+        throw new Error('binary data exhausted');
+      }
+
+      var dataView = bytes ? new DataView(this.arrayBuffer, this.offset, bytes) : new DataView(this.arrayBuffer, this.offset);
+      this.offset += bytes;
+      return dataView;
+    }
+  }, {
+    key: "skip",
+    value: function skip(bytes) {
+      this.offset += bytes;
+    }
+  }, {
+    key: "rewind",
+    value: function rewind(bytes) {
+      this.offset -= bytes;
+    }
+  }]);
+  return BinaryReader;
+}();
 
 exports.default = BinaryReader;
 //# sourceMappingURL=binary-reader.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/streaming/binary-reader.ts"],"names":["BinaryReader","constructor","arrayBuffer","offset","hasAvailableBytes","bytes","byteLength","getDataView","Error","dataView","DataView","skip","rewind"],"mappings":";;;;;;;;;;;AAAe,MAAMA,YAAN,CAAmB;AAIhCC,EAAAA,WAAW,CAACC,WAAD,EAA2B;AAAA;AAAA;AAEpC,SAAKC,MAAL,GAAc,CAAd;AAEA,SAAKD,WAAL,GAAmBA,WAAnB;AACD;;AAODE,EAAAA,iBAAiB,CAACC,KAAD,EAAyB;AACxC,WAAO,KAAKH,WAAL,CAAiBI,UAAjB,GAA8B,KAAKH,MAAnC,IAA6CE,KAApD;AACD;;AAQDE,EAAAA,WAAW,CAACF,KAAD,EAA0B;AACnC,QAAIA,KAAK,IAAI,CAAC,KAAKD,iBAAL,CAAuBC,KAAvB,CAAd,EAA6C;AAC3C,YAAM,IAAIG,KAAJ,CAAU,uBAAV,CAAN;AACD;;AAED,UAAMC,QAAQ,GAAGJ,KAAK,GAClB,IAAIK,QAAJ,CAAa,KAAKR,WAAlB,EAA+B,KAAKC,MAApC,EAA4CE,KAA5C,CADkB,GAElB,IAAIK,QAAJ,CAAa,KAAKR,WAAlB,EAA+B,KAAKC,MAApC,CAFJ;AAGA,SAAKA,MAAL,IAAeE,KAAf;AACA,WAAOI,QAAP;AACD;;AAODE,EAAAA,IAAI,CAACN,KAAD,EAAsB;AACxB,SAAKF,MAAL,IAAeE,KAAf;AACD;;AAODO,EAAAA,MAAM,CAACP,KAAD,EAAsB;AAC1B,SAAKF,MAAL,IAAeE,KAAf;AACD;;AAtD+B","sourcesContent":["export default class BinaryReader {\n  offset: number;\n  arrayBuffer: ArrayBuffer;\n\n  constructor(arrayBuffer: ArrayBuffer) {\n    /** current global (stream) offset */\n    this.offset = 0;\n    /** current buffer from iterator */\n    this.arrayBuffer = arrayBuffer;\n  }\n  /**\n   * Checks if there are available bytes in data\n   *\n   * @param bytes\n   * @returns boolean\n   */\n  hasAvailableBytes(bytes: number): boolean {\n    return this.arrayBuffer.byteLength - this.offset >= bytes;\n  }\n\n  /**\n   * Get the required number of bytes from the iterator\n   *\n   * @param bytes\n   * @returns Dataview\n   */\n  getDataView(bytes: number): DataView {\n    if (bytes && !this.hasAvailableBytes(bytes)) {\n      throw new Error('binary data exhausted');\n    }\n\n    const dataView = bytes\n      ? new DataView(this.arrayBuffer, this.offset, bytes)\n      : new DataView(this.arrayBuffer, this.offset);\n    this.offset += bytes;\n    return dataView;\n  }\n\n  /**\n   * Skipping\n   *\n   * @param bytes\n   */\n  skip(bytes: number): void {\n    this.offset += bytes;\n  }\n\n  /**\n   * Rewinding\n   *\n   * @param bytes\n   */\n  rewind(bytes: number): void {\n    this.offset -= bytes;\n  }\n}\n"],"file":"binary-reader.js"}
+{"version":3,"sources":["../../../../src/lib/streaming/binary-reader.ts"],"names":["BinaryReader","arrayBuffer","offset","bytes","byteLength","hasAvailableBytes","Error","dataView","DataView"],"mappings":";;;;;;;;;;;;;;;IAAqBA,Y;AAInB,wBAAYC,WAAZ,EAAsC;AAAA;AAAA;AAAA;AAEpC,SAAKC,MAAL,GAAc,CAAd;AAEA,SAAKD,WAAL,GAAmBA,WAAnB;AACD;;;;WAOD,2BAAkBE,KAAlB,EAA0C;AACxC,aAAO,KAAKF,WAAL,CAAiBG,UAAjB,GAA8B,KAAKF,MAAnC,IAA6CC,KAApD;AACD;;;WAQD,qBAAYA,KAAZ,EAAqC;AACnC,UAAIA,KAAK,IAAI,CAAC,KAAKE,iBAAL,CAAuBF,KAAvB,CAAd,EAA6C;AAC3C,cAAM,IAAIG,KAAJ,CAAU,uBAAV,CAAN;AACD;;AAED,UAAMC,QAAQ,GAAGJ,KAAK,GAClB,IAAIK,QAAJ,CAAa,KAAKP,WAAlB,EAA+B,KAAKC,MAApC,EAA4CC,KAA5C,CADkB,GAElB,IAAIK,QAAJ,CAAa,KAAKP,WAAlB,EAA+B,KAAKC,MAApC,CAFJ;AAGA,WAAKA,MAAL,IAAeC,KAAf;AACA,aAAOI,QAAP;AACD;;;WAOD,cAAKJ,KAAL,EAA0B;AACxB,WAAKD,MAAL,IAAeC,KAAf;AACD;;;WAOD,gBAAOA,KAAP,EAA4B;AAC1B,WAAKD,MAAL,IAAeC,KAAf;AACD","sourcesContent":["export default class BinaryReader {\n  offset: number;\n  arrayBuffer: ArrayBuffer;\n\n  constructor(arrayBuffer: ArrayBuffer) {\n    /** current global (stream) offset */\n    this.offset = 0;\n    /** current buffer from iterator */\n    this.arrayBuffer = arrayBuffer;\n  }\n  /**\n   * Checks if there are available bytes in data\n   *\n   * @param bytes\n   * @returns boolean\n   */\n  hasAvailableBytes(bytes: number): boolean {\n    return this.arrayBuffer.byteLength - this.offset >= bytes;\n  }\n\n  /**\n   * Get the required number of bytes from the iterator\n   *\n   * @param bytes\n   * @returns Dataview\n   */\n  getDataView(bytes: number): DataView {\n    if (bytes && !this.hasAvailableBytes(bytes)) {\n      throw new Error('binary data exhausted');\n    }\n\n    const dataView = bytes\n      ? new DataView(this.arrayBuffer, this.offset, bytes)\n      : new DataView(this.arrayBuffer, this.offset);\n    this.offset += bytes;\n    return dataView;\n  }\n\n  /**\n   * Skipping\n   *\n   * @param bytes\n   */\n  skip(bytes: number): void {\n    this.offset += bytes;\n  }\n\n  /**\n   * Rewinding\n   *\n   * @param bytes\n   */\n  rewind(bytes: number): void {\n    this.offset -= bytes;\n  }\n}\n"],"file":"binary-reader.js"}

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

@@ -1,57 +1,116 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.zipBatchIterators = zipBatchIterators;
 
-async function* zipBatchIterators(iterator1, iterator2) {
-  let batch1 = [];
-  let batch2 = [];
-  let iterator1Done = false;
-  let iterator2Done = false;
-
-  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;
-      }
-    }
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
-    const batch = extractBatch(batch1, batch2);
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
 
-    if (batch) {
-      yield batch;
-    }
-  }
+var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+
+function zipBatchIterators(_x, _x2) {
+  return _zipBatchIterators.apply(this, arguments);
+}
+
+function _zipBatchIterators() {
+  _zipBatchIterators = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee(iterator1, iterator2) {
+    var batch1, batch2, iterator1Done, iterator2Done, _yield$_awaitAsyncGen, value, done, _yield$_awaitAsyncGen2, _value, _done, batch;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            batch1 = [];
+            batch2 = [];
+            iterator1Done = false;
+            iterator2Done = false;
+
+          case 4:
+            if (!(!iterator1Done && !iterator2Done)) {
+              _context.next = 27;
+              break;
+            }
+
+            if (!(batch1.length === 0 && !iterator1Done)) {
+              _context.next = 14;
+              break;
+            }
+
+            _context.next = 8;
+            return (0, _awaitAsyncGenerator2.default)(iterator1.next());
+
+          case 8:
+            _yield$_awaitAsyncGen = _context.sent;
+            value = _yield$_awaitAsyncGen.value;
+            done = _yield$_awaitAsyncGen.done;
+
+            if (done) {
+              iterator1Done = true;
+            } else {
+              batch1 = value;
+            }
+
+            _context.next = 21;
+            break;
+
+          case 14:
+            if (!(batch2.length === 0 && !iterator2Done)) {
+              _context.next = 21;
+              break;
+            }
+
+            _context.next = 17;
+            return (0, _awaitAsyncGenerator2.default)(iterator2.next());
+
+          case 17:
+            _yield$_awaitAsyncGen2 = _context.sent;
+            _value = _yield$_awaitAsyncGen2.value;
+            _done = _yield$_awaitAsyncGen2.done;
+
+            if (_done) {
+              iterator2Done = true;
+            } else {
+              batch2 = _value;
+            }
+
+          case 21:
+            batch = extractBatch(batch1, batch2);
+
+            if (!batch) {
+              _context.next = 25;
+              break;
+            }
+
+            _context.next = 25;
+            return batch;
+
+          case 25:
+            _context.next = 4;
+            break;
+
+          case 27:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _zipBatchIterators.apply(this, arguments);
 }
 
 function extractBatch(batch1, batch2) {
-  const batchLength = Math.min(batch1.length, batch2.length);
+  var batchLength = Math.min(batch1.length, batch2.length);
 
   if (batchLength === 0) {
     return null;
   }
 
-  const batch = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];
+  var batch = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];
   batch1.splice(0, batchLength);
   batch2.splice(0, batchLength);
   return batch;

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/streaming/zip-batch-iterators.ts"],"names":["zipBatchIterators","iterator1","iterator2","batch1","batch2","iterator1Done","iterator2Done","length","value","done","next","batch","extractBatch","batchLength","Math","min","slice","splice"],"mappings":";;;;;;;AAMO,gBAAgBA,iBAAhB,CACLC,SADK,EAELC,SAFK,EAGsC;AAC3C,MAAIC,MAAM,GAAG,EAAb;AACA,MAAIC,MAAM,GAAG,EAAb;AACA,MAAIC,aAAsB,GAAG,KAA7B;AACA,MAAIC,aAAsB,GAAG,KAA7B;;AAIA,SAAO,CAACD,aAAD,IAAkB,CAACC,aAA1B,EAAyC;AACvC,QAAIH,MAAM,CAACI,MAAP,KAAkB,CAAlB,IAAuB,CAACF,aAA5B,EAA2C;AACzC,YAAM;AAACG,QAAAA,KAAD;AAAQC,QAAAA;AAAR,UAAgB,MAAMR,SAAS,CAACS,IAAV,EAA5B;;AACA,UAAID,IAAJ,EAAU;AACRJ,QAAAA,aAAa,GAAG,IAAhB;AACD,OAFD,MAEO;AACLF,QAAAA,MAAM,GAAGK,KAAT;AACD;AACF,KAPD,MAOO,IAAIJ,MAAM,CAACG,MAAP,KAAkB,CAAlB,IAAuB,CAACD,aAA5B,EAA2C;AAChD,YAAM;AAACE,QAAAA,KAAD;AAAQC,QAAAA;AAAR,UAAgB,MAAMP,SAAS,CAACQ,IAAV,EAA5B;;AACA,UAAID,IAAJ,EAAU;AACRH,QAAAA,aAAa,GAAG,IAAhB;AACD,OAFD,MAEO;AACLF,QAAAA,MAAM,GAAGI,KAAT;AACD;AACF;;AAED,UAAMG,KAAK,GAAGC,YAAY,CAACT,MAAD,EAASC,MAAT,CAA1B;;AACA,QAAIO,KAAJ,EAAW;AACT,YAAMA,KAAN;AACD;AACF;AACF;;AASD,SAASC,YAAT,CAAsBT,MAAtB,EAAwCC,MAAxC,EAA6E;AAC3E,QAAMS,WAAmB,GAAGC,IAAI,CAACC,GAAL,CAASZ,MAAM,CAACI,MAAhB,EAAwBH,MAAM,CAACG,MAA/B,CAA5B;;AACA,MAAIM,WAAW,KAAK,CAApB,EAAuB;AACrB,WAAO,IAAP;AACD;;AAGD,QAAMF,KAAiB,GAAG,CAACR,MAAM,CAACa,KAAP,CAAa,CAAb,EAAgBH,WAAhB,CAAD,EAA+BT,MAAM,CAACY,KAAP,CAAa,CAAb,EAAgBH,WAAhB,CAA/B,CAA1B;AAGAV,EAAAA,MAAM,CAACc,MAAP,CAAc,CAAd,EAAiBJ,WAAjB;AACAT,EAAAA,MAAM,CAACa,MAAP,CAAc,CAAd,EAAiBJ,WAAjB;AACA,SAAOF,KAAP;AACD","sourcesContent":["/**\n * Zip two iterators together\n *\n * @param iterator1\n * @param iterator2\n */\nexport async function* zipBatchIterators(\n  iterator1: AsyncIterator<any[]>,\n  iterator2: AsyncIterator<any[]>\n): AsyncGenerator<number[][], void, unknown> {\n  let batch1 = [];\n  let batch2 = [];\n  let iterator1Done: boolean = false;\n  let iterator2Done: boolean = false;\n\n  // TODO - one could let all iterators flow at full speed using `Promise.race`\n  // however we might end up with a big temporary buffer\n  while (!iterator1Done && !iterator2Done) {\n    if (batch1.length === 0 && !iterator1Done) {\n      const {value, done} = await iterator1.next();\n      if (done) {\n        iterator1Done = true;\n      } else {\n        batch1 = value;\n      }\n    } else if (batch2.length === 0 && !iterator2Done) {\n      const {value, done} = await iterator2.next();\n      if (done) {\n        iterator2Done = true;\n      } else {\n        batch2 = value;\n      }\n    }\n\n    const batch = extractBatch(batch1, batch2);\n    if (batch) {\n      yield batch;\n    }\n  }\n}\n\n/**\n * Extract batch of same length from two batches\n *\n * @param batch1\n * @param batch2\n * @return array | null\n */\nfunction extractBatch(batch1: number[], batch2: number[]): number[][] | null {\n  const batchLength: number = Math.min(batch1.length, batch2.length);\n  if (batchLength === 0) {\n    return null;\n  }\n\n  // Non interleaved arrays\n  const batch: number[][] = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];\n\n  // Modify the 2 batches\n  batch1.splice(0, batchLength);\n  batch2.splice(0, batchLength);\n  return batch;\n}\n"],"file":"zip-batch-iterators.js"}
+{"version":3,"sources":["../../../../src/lib/streaming/zip-batch-iterators.ts"],"names":["zipBatchIterators","iterator1","iterator2","batch1","batch2","iterator1Done","iterator2Done","length","next","value","done","batch","extractBatch","batchLength","Math","min","slice","splice"],"mappings":";;;;;;;;;;;;;;;SAMuBA,iB;;;;;mFAAhB,iBACLC,SADK,EAELC,SAFK;AAAA;;AAAA;AAAA;AAAA;AAAA;AAIDC,YAAAA,MAJC,GAIQ,EAJR;AAKDC,YAAAA,MALC,GAKQ,EALR;AAMDC,YAAAA,aANC,GAMwB,KANxB;AAODC,YAAAA,aAPC,GAOwB,KAPxB;;AAAA;AAAA,kBAWE,CAACD,aAAD,IAAkB,CAACC,aAXrB;AAAA;AAAA;AAAA;;AAAA,kBAYCH,MAAM,CAACI,MAAP,KAAkB,CAAlB,IAAuB,CAACF,aAZzB;AAAA;AAAA;AAAA;;AAAA;AAAA,sDAa2BJ,SAAS,CAACO,IAAV,EAb3B;;AAAA;AAAA;AAaMC,YAAAA,KAbN,yBAaMA,KAbN;AAaaC,YAAAA,IAbb,yBAaaA,IAbb;;AAcD,gBAAIA,IAAJ,EAAU;AACRL,cAAAA,aAAa,GAAG,IAAhB;AACD,aAFD,MAEO;AACLF,cAAAA,MAAM,GAAGM,KAAT;AACD;;AAlBA;AAAA;;AAAA;AAAA,kBAmBQL,MAAM,CAACG,MAAP,KAAkB,CAAlB,IAAuB,CAACD,aAnBhC;AAAA;AAAA;AAAA;;AAAA;AAAA,sDAoB2BJ,SAAS,CAACM,IAAV,EApB3B;;AAAA;AAAA;AAoBMC,YAAAA,MApBN,0BAoBMA,KApBN;AAoBaC,YAAAA,KApBb,0BAoBaA,IApBb;;AAqBD,gBAAIA,KAAJ,EAAU;AACRJ,cAAAA,aAAa,GAAG,IAAhB;AACD,aAFD,MAEO;AACLF,cAAAA,MAAM,GAAGK,MAAT;AACD;;AAzBA;AA4BGE,YAAAA,KA5BH,GA4BWC,YAAY,CAACT,MAAD,EAASC,MAAT,CA5BvB;;AAAA,iBA6BCO,KA7BD;AAAA;AAAA;AAAA;;AAAA;AA8BD,mBAAMA,KAAN;;AA9BC;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AA0CP,SAASC,YAAT,CAAsBT,MAAtB,EAAwCC,MAAxC,EAA6E;AAC3E,MAAMS,WAAmB,GAAGC,IAAI,CAACC,GAAL,CAASZ,MAAM,CAACI,MAAhB,EAAwBH,MAAM,CAACG,MAA/B,CAA5B;;AACA,MAAIM,WAAW,KAAK,CAApB,EAAuB;AACrB,WAAO,IAAP;AACD;;AAGD,MAAMF,KAAiB,GAAG,CAACR,MAAM,CAACa,KAAP,CAAa,CAAb,EAAgBH,WAAhB,CAAD,EAA+BT,MAAM,CAACY,KAAP,CAAa,CAAb,EAAgBH,WAAhB,CAA/B,CAA1B;AAGAV,EAAAA,MAAM,CAACc,MAAP,CAAc,CAAd,EAAiBJ,WAAjB;AACAT,EAAAA,MAAM,CAACa,MAAP,CAAc,CAAd,EAAiBJ,WAAjB;AACA,SAAOF,KAAP;AACD","sourcesContent":["/**\n * Zip two iterators together\n *\n * @param iterator1\n * @param iterator2\n */\nexport async function* zipBatchIterators(\n  iterator1: AsyncIterator<any[]>,\n  iterator2: AsyncIterator<any[]>\n): AsyncGenerator<number[][], void, unknown> {\n  let batch1 = [];\n  let batch2 = [];\n  let iterator1Done: boolean = false;\n  let iterator2Done: boolean = false;\n\n  // TODO - one could let all iterators flow at full speed using `Promise.race`\n  // however we might end up with a big temporary buffer\n  while (!iterator1Done && !iterator2Done) {\n    if (batch1.length === 0 && !iterator1Done) {\n      const {value, done} = await iterator1.next();\n      if (done) {\n        iterator1Done = true;\n      } else {\n        batch1 = value;\n      }\n    } else if (batch2.length === 0 && !iterator2Done) {\n      const {value, done} = await iterator2.next();\n      if (done) {\n        iterator2Done = true;\n      } else {\n        batch2 = value;\n      }\n    }\n\n    const batch = extractBatch(batch1, batch2);\n    if (batch) {\n      yield batch;\n    }\n  }\n}\n\n/**\n * Extract batch of same length from two batches\n *\n * @param batch1\n * @param batch2\n * @return array | null\n */\nfunction extractBatch(batch1: number[], batch2: number[]): number[][] | null {\n  const batchLength: number = Math.min(batch1.length, batch2.length);\n  if (batchLength === 0) {\n    return null;\n  }\n\n  // Non interleaved arrays\n  const batch: number[][] = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];\n\n  // Modify the 2 batches\n  batch1.splice(0, batchLength);\n  batch2.splice(0, batchLength);\n  return batch;\n}\n"],"file":"zip-batch-iterators.js"}

package/dist/es5/shapefile-loader.js

@@ -9,8 +9,8 @@ var _shpLoader = require("./shp-loader");
 
 var _parseShapefile = require("./lib/parsers/parse-shapefile");
 
-const VERSION = typeof "3.1.0-beta.5" !== 'undefined' ? "3.1.0-beta.5" : 'latest';
-const ShapefileLoader = {
+var VERSION = typeof "3.1.2" !== 'undefined' ? "3.1.2" : 'latest';
+var ShapefileLoader = {
   name: 'Shapefile',
   id: 'shapefile',
   module: 'shapefile',
@@ -29,6 +29,6 @@ const ShapefileLoader = {
   parseInBatches: _parseShapefile.parseShapefileInBatches
 };
 exports.ShapefileLoader = ShapefileLoader;
-const _typecheckShapefileLoader = ShapefileLoader;
+var _typecheckShapefileLoader = ShapefileLoader;
 exports._typecheckShapefileLoader = _typecheckShapefileLoader;
 //# sourceMappingURL=shapefile-loader.js.map