@loaders.gl/shapefile 3.1.0-beta.2 → 3.1.0

package/dist/bundle.js

@@ -7432,6 +7432,9 @@
     return features;
   }
   function reprojectFeatures(features, sourceCrs, targetCrs) {
+    if (!sourceCrs && !targetCrs) {
+      return features;
+    }
     const projection = new Proj4Projection({ from: sourceCrs || "WGS84", to: targetCrs || "WGS84" });
     return transformGeoJsonCoords(features, (coord) => projection.project(coord));
   }

package/dist/es5/bundle.js

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

package/dist/es5/bundle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}
+{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/es5/dbf-loader.js

@@ -1,14 +1,26 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.DBFLoader = exports.DBFWorkerLoader = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _parseDbf = require("./lib/parsers/parse-dbf");
 
-const VERSION = typeof "3.1.0-beta.2" !== 'undefined' ? "3.1.0-beta.2" : 'latest';
-const DBFWorkerLoader = {
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var VERSION = typeof "3.1.0" !== 'undefined' ? "3.1.0" : 'latest';
+var DBFWorkerLoader = {
   name: 'DBF',
   id: 'dbf',
   module: 'shapefile',
@@ -24,10 +36,33 @@ const DBFWorkerLoader = {
   }
 };
 exports.DBFWorkerLoader = DBFWorkerLoader;
-const DBFLoader = { ...DBFWorkerLoader,
-  parse: async (arrayBuffer, options) => (0, _parseDbf.parseDBF)(arrayBuffer, options),
+
+var DBFLoader = _objectSpread(_objectSpread({}, DBFWorkerLoader), {}, {
+  parse: function () {
+    var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, options) {
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", (0, _parseDbf.parseDBF)(arrayBuffer, options));
+
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    function parse(_x, _x2) {
+      return _parse.apply(this, arguments);
+    }
+
+    return parse;
+  }(),
   parseSync: _parseDbf.parseDBF,
   parseInBatches: _parseDbf.parseDBFInBatches
-};
+});
+
 exports.DBFLoader = DBFLoader;
 //# sourceMappingURL=dbf-loader.js.map

package/dist/es5/dbf-loader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/dbf-loader.ts"],"names":["VERSION","DBFWorkerLoader","name","id","module","version","worker","category","extensions","mimeTypes","options","dbf","encoding","DBFLoader","parse","arrayBuffer","parseSync","parseDBF","parseInBatches","parseDBFInBatches"],"mappings":";;;;;;;AACA;;AAIA,MAAMA,OAAO,GAAG,0BAAuB,WAAvB,oBAAmD,QAAnE;AAKO,MAAMC,eAAuB,GAAG;AACrCC,EAAAA,IAAI,EAAE,KAD+B;AAErCC,EAAAA,EAAE,EAAE,KAFiC;AAGrCC,EAAAA,MAAM,EAAE,WAH6B;AAIrCC,EAAAA,OAAO,EAAEL,OAJ4B;AAKrCM,EAAAA,MAAM,EAAE,IAL6B;AAMrCC,EAAAA,QAAQ,EAAE,OAN2B;AAOrCC,EAAAA,UAAU,EAAE,CAAC,KAAD,CAPyB;AAQrCC,EAAAA,SAAS,EAAE,CAAC,mBAAD,CAR0B;AASrCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,GAAG,EAAE;AACHC,MAAAA,QAAQ,EAAE;AADP;AADE;AAT4B,CAAhC;;AAiBA,MAAMC,SAA2B,GAAG,EACzC,GAAGZ,eADsC;AAEzCa,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAoBL,OAApB,KAAgC,wBAASK,WAAT,EAAsBL,OAAtB,CAFE;AAGzCM,EAAAA,SAAS,EAAEC,kBAH8B;AAIzCC,EAAAA,cAAc,EAAEC;AAJyB,CAApC","sourcesContent":["import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {parseDBF, parseDBFInBatches} from './lib/parsers/parse-dbf';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * DBFLoader - DBF files are used to contain non-geometry columns in Shapefiles\n */\nexport const DBFWorkerLoader: Loader = {\n  name: 'DBF',\n  id: 'dbf',\n  module: 'shapefile',\n  version: VERSION,\n  worker: true,\n  category: 'table',\n  extensions: ['dbf'],\n  mimeTypes: ['application/x-dbf'],\n  options: {\n    dbf: {\n      encoding: 'latin1'\n    }\n  }\n};\n\n/** DBF file loader */\nexport const DBFLoader: LoaderWithParser = {\n  ...DBFWorkerLoader,\n  parse: async (arrayBuffer, options) => parseDBF(arrayBuffer, options),\n  parseSync: parseDBF,\n  parseInBatches: parseDBFInBatches\n};\n"],"file":"dbf-loader.js"}
+{"version":3,"sources":["../../src/dbf-loader.ts"],"names":["VERSION","DBFWorkerLoader","name","id","module","version","worker","category","extensions","mimeTypes","options","dbf","encoding","DBFLoader","parse","arrayBuffer","parseSync","parseDBF","parseInBatches","parseDBFInBatches"],"mappings":";;;;;;;;;;;;;;;AACA;;;;;;AAIA,IAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAKO,IAAMC,eAAuB,GAAG;AACrCC,EAAAA,IAAI,EAAE,KAD+B;AAErCC,EAAAA,EAAE,EAAE,KAFiC;AAGrCC,EAAAA,MAAM,EAAE,WAH6B;AAIrCC,EAAAA,OAAO,EAAEL,OAJ4B;AAKrCM,EAAAA,MAAM,EAAE,IAL6B;AAMrCC,EAAAA,QAAQ,EAAE,OAN2B;AAOrCC,EAAAA,UAAU,EAAE,CAAC,KAAD,CAPyB;AAQrCC,EAAAA,SAAS,EAAE,CAAC,mBAAD,CAR0B;AASrCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,GAAG,EAAE;AACHC,MAAAA,QAAQ,EAAE;AADP;AADE;AAT4B,CAAhC;;;AAiBA,IAAMC,SAA2B,mCACnCZ,eADmC;AAEtCa,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP,EAAoBL,OAApB;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAgC,wBAASK,WAAT,EAAsBL,OAAtB,CAAhC;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAFiC;AAGtCM,EAAAA,SAAS,EAAEC,kBAH2B;AAItCC,EAAAA,cAAc,EAAEC;AAJsB,EAAjC","sourcesContent":["import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {parseDBF, parseDBFInBatches} from './lib/parsers/parse-dbf';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * DBFLoader - DBF files are used to contain non-geometry columns in Shapefiles\n */\nexport const DBFWorkerLoader: Loader = {\n  name: 'DBF',\n  id: 'dbf',\n  module: 'shapefile',\n  version: VERSION,\n  worker: true,\n  category: 'table',\n  extensions: ['dbf'],\n  mimeTypes: ['application/x-dbf'],\n  options: {\n    dbf: {\n      encoding: 'latin1'\n    }\n  }\n};\n\n/** DBF file loader */\nexport const DBFLoader: LoaderWithParser = {\n  ...DBFWorkerLoader,\n  parse: async (arrayBuffer, options) => parseDBF(arrayBuffer, options),\n  parseSync: parseDBF,\n  parseInBatches: parseDBFInBatches\n};\n"],"file":"dbf-loader.js"}

package/dist/es5/index.js

@@ -5,31 +5,31 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "ShapefileLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _shapefileLoader.ShapefileLoader;
   }
 });
 Object.defineProperty(exports, "DBFLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _dbfLoader.DBFLoader;
   }
 });
 Object.defineProperty(exports, "DBFWorkerLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _dbfLoader.DBFWorkerLoader;
   }
 });
 Object.defineProperty(exports, "SHPLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _shpLoader.SHPLoader;
   }
 });
 Object.defineProperty(exports, "SHPWorkerLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _shpLoader.SHPWorkerLoader;
   }
 });

package/dist/es5/lib/parsers/parse-dbf.js

@@ -8,14 +8,32 @@ Object.defineProperty(exports, "__esModule", {
 exports.parseDBF = parseDBF;
 exports.parseDBFInBatches = parseDBFInBatches;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
+
+var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+
+var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
+
 var _schema = require("@loaders.gl/schema");
 
 var _binaryChunkReader = _interopRequireDefault(require("../streaming/binary-chunk-reader"));
 
-const LITTLE_ENDIAN = true;
-const DBF_HEADER_SIZE = 32;
+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 LITTLE_ENDIAN = true;
+var DBF_HEADER_SIZE = 32;
 var STATE;
 
 (function (STATE) {
@@ -26,8 +44,9 @@ var STATE;
   STATE[STATE["ERROR"] = 4] = "ERROR";
 })(STATE || (STATE = {}));
 
-class DBFParser {
-  constructor(options) {
+var DBFParser = function () {
+  function DBFParser(options) {
+    (0, _classCallCheck2.default)(this, DBFParser);
     (0, _defineProperty2.default)(this, "binaryReader", new _binaryChunkReader.default());
     (0, _defineProperty2.default)(this, "textDecoder", void 0);
     (0, _defineProperty2.default)(this, "state", STATE.START);
@@ -37,42 +56,44 @@ class DBFParser {
     this.textDecoder = new TextDecoder(options.encoding);
   }
 
-  write(arrayBuffer) {
-    this.binaryReader.write(arrayBuffer);
-    this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
-  }
-
-  end() {
-    this.binaryReader.end();
-    this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
-
-    if (this.state !== STATE.END) {
-      this.state = STATE.ERROR;
-      this.result.error = 'DBF incomplete file';
+  (0, _createClass2.default)(DBFParser, [{
+    key: "write",
+    value: function write(arrayBuffer) {
+      this.binaryReader.write(arrayBuffer);
+      this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
     }
-  }
-
-}
-
-function parseDBF(arrayBuffer, options = {}) {
-  const loaderOptions = options.dbf || {};
-  const {
-    encoding
-  } = loaderOptions;
-  const dbfParser = new DBFParser({
-    encoding
+  }, {
+    key: "end",
+    value: function end() {
+      this.binaryReader.end();
+      this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);
+
+      if (this.state !== STATE.END) {
+        this.state = STATE.ERROR;
+        this.result.error = 'DBF incomplete file';
+      }
+    }
+  }]);
+  return DBFParser;
+}();
+
+function parseDBF(arrayBuffer) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var loaderOptions = options.dbf || {};
+  var encoding = loaderOptions.encoding;
+  var dbfParser = new DBFParser({
+    encoding: encoding
   });
   dbfParser.write(arrayBuffer);
   dbfParser.end();
-  const {
-    data,
-    schema
-  } = dbfParser.result;
+  var _dbfParser$result = dbfParser.result,
+      data = _dbfParser$result.data,
+      schema = _dbfParser$result.schema;
 
   switch (options.tables && options.tables.format) {
     case 'table':
       return {
-        schema,
+        schema: schema,
         rows: data
       };
 
@@ -82,35 +103,146 @@ function parseDBF(arrayBuffer, options = {}) {
   }
 }
 
-async function* parseDBFInBatches(asyncIterator, options = {}) {
-  const loaderOptions = options.dbf || {};
-  const {
-    encoding
-  } = loaderOptions;
-  const parser = new DBFParser({
-    encoding
-  });
-  let headerReturned = false;
+function parseDBFInBatches(_x) {
+  return _parseDBFInBatches.apply(this, arguments);
+}
 
-  for await (const arrayBuffer of asyncIterator) {
-    parser.write(arrayBuffer);
+function _parseDBFInBatches() {
+  _parseDBFInBatches = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee(asyncIterator) {
+    var options,
+        loaderOptions,
+        encoding,
+        parser,
+        headerReturned,
+        _iteratorNormalCompletion,
+        _didIteratorError,
+        _iteratorError,
+        _iterator,
+        _step,
+        _value,
+        arrayBuffer,
+        _args = arguments;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+            loaderOptions = options.dbf || {};
+            encoding = loaderOptions.encoding;
+            parser = new DBFParser({
+              encoding: encoding
+            });
+            headerReturned = false;
+            _iteratorNormalCompletion = true;
+            _didIteratorError = false;
+            _context.prev = 7;
+            _iterator = (0, _asyncIterator2.default)(asyncIterator);
+
+          case 9:
+            _context.next = 11;
+            return (0, _awaitAsyncGenerator2.default)(_iterator.next());
+
+          case 11:
+            _step = _context.sent;
+            _iteratorNormalCompletion = _step.done;
+            _context.next = 15;
+            return (0, _awaitAsyncGenerator2.default)(_step.value);
+
+          case 15:
+            _value = _context.sent;
+
+            if (_iteratorNormalCompletion) {
+              _context.next = 30;
+              break;
+            }
 
-    if (!headerReturned && parser.result.dbfHeader) {
-      headerReturned = true;
-      yield parser.result.dbfHeader;
-    }
+            arrayBuffer = _value;
+            parser.write(arrayBuffer);
 
-    if (parser.result.data.length > 0) {
-      yield parser.result.data;
-      parser.result.data = [];
-    }
-  }
+            if (!(!headerReturned && parser.result.dbfHeader)) {
+              _context.next = 23;
+              break;
+            }
 
-  parser.end();
+            headerReturned = true;
+            _context.next = 23;
+            return parser.result.dbfHeader;
 
-  if (parser.result.data.length > 0) {
-    yield parser.result.data;
-  }
+          case 23:
+            if (!(parser.result.data.length > 0)) {
+              _context.next = 27;
+              break;
+            }
+
+            _context.next = 26;
+            return parser.result.data;
+
+          case 26:
+            parser.result.data = [];
+
+          case 27:
+            _iteratorNormalCompletion = true;
+            _context.next = 9;
+            break;
+
+          case 30:
+            _context.next = 36;
+            break;
+
+          case 32:
+            _context.prev = 32;
+            _context.t0 = _context["catch"](7);
+            _didIteratorError = true;
+            _iteratorError = _context.t0;
+
+          case 36:
+            _context.prev = 36;
+            _context.prev = 37;
+
+            if (!(!_iteratorNormalCompletion && _iterator.return != null)) {
+              _context.next = 41;
+              break;
+            }
+
+            _context.next = 41;
+            return (0, _awaitAsyncGenerator2.default)(_iterator.return());
+
+          case 41:
+            _context.prev = 41;
+
+            if (!_didIteratorError) {
+              _context.next = 44;
+              break;
+            }
+
+            throw _iteratorError;
+
+          case 44:
+            return _context.finish(41);
+
+          case 45:
+            return _context.finish(36);
+
+          case 46:
+            parser.end();
+
+            if (!(parser.result.data.length > 0)) {
+              _context.next = 50;
+              break;
+            }
+
+            _context.next = 50;
+            return parser.result.data;
+
+          case 50:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[7, 32, 36, 46], [37,, 41, 45]]);
+  }));
+  return _parseDBFInBatches.apply(this, arguments);
 }
 
 function parseState(state, result, binaryReader, textDecoder) {
@@ -122,7 +254,7 @@ function parseState(state, result, binaryReader, textDecoder) {
           return state;
 
         case STATE.START:
-          const dataView = binaryReader.getDataView(DBF_HEADER_SIZE, 'DBF header');
+          var dataView = binaryReader.getDataView(DBF_HEADER_SIZE, 'DBF header');
 
           if (!dataView) {
             return state;
@@ -138,33 +270,36 @@ function parseState(state, result, binaryReader, textDecoder) {
           break;
 
         case STATE.FIELD_DESCRIPTORS:
-          const fieldDescriptorView = binaryReader.getDataView(result.dbfHeader.headerLength - DBF_HEADER_SIZE, 'DBF field descriptors');
+          var fieldDescriptorView = binaryReader.getDataView(result.dbfHeader.headerLength - DBF_HEADER_SIZE, 'DBF field descriptors');
 
           if (!fieldDescriptorView) {
             return state;
           }
 
           result.dbfFields = parseFieldDescriptors(fieldDescriptorView, textDecoder);
-          result.schema = new _schema.Schema(result.dbfFields.map(dbfField => makeField(dbfField)));
+          result.schema = new _schema.Schema(result.dbfFields.map(function (dbfField) {
+            return makeField(dbfField);
+          }));
           state = STATE.FIELD_PROPERTIES;
           binaryReader.skip(1);
           break;
 
         case STATE.FIELD_PROPERTIES:
-          const {
-            recordLength = 0,
-            nRecords = 0
-          } = (result === null || result === void 0 ? void 0 : result.dbfHeader) || {};
+          var _ref = (result === null || result === void 0 ? void 0 : result.dbfHeader) || {},
+              _ref$recordLength = _ref.recordLength,
+              recordLength = _ref$recordLength === void 0 ? 0 : _ref$recordLength,
+              _ref$nRecords = _ref.nRecords,
+              nRecords = _ref$nRecords === void 0 ? 0 : _ref$nRecords;
 
           while (result.data.length < nRecords) {
-            const recordView = binaryReader.getDataView(recordLength - 1);
+            var recordView = binaryReader.getDataView(recordLength - 1);
 
             if (!recordView) {
               return state;
             }
 
             binaryReader.skip(1);
-            const row = parseRow(recordView, result.dbfFields, textDecoder);
+            var row = parseRow(recordView, result.dbfFields, textDecoder);
             result.data.push(row);
             result.progress.rows = result.data.length;
           }
@@ -198,14 +333,14 @@ function parseDBFHeader(headerView) {
 }
 
 function parseFieldDescriptors(view, textDecoder) {
-  const nFields = (view.byteLength - 1) / 32;
-  const fields = [];
-  let offset = 0;
+  var nFields = (view.byteLength - 1) / 32;
+  var fields = [];
+  var offset = 0;
 
-  for (let i = 0; i < nFields; i++) {
-    const name = textDecoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset, 11)).replace(/\u0000/g, '');
+  for (var i = 0; i < nFields; i++) {
+    var name = textDecoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset, 11)).replace(/\u0000/g, '');
     fields.push({
-      name,
+      name: name,
       dataType: String.fromCharCode(view.getUint8(offset + 11)),
       fieldLength: view.getUint8(offset + 16),
       decimal: view.getUint8(offset + 17)
@@ -217,13 +352,23 @@ function parseFieldDescriptors(view, textDecoder) {
 }
 
 function parseRow(view, fields, textDecoder) {
-  const out = {};
-  let offset = 0;
-
-  for (const field of fields) {
-    const text = textDecoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset, field.fieldLength));
-    out[field.name] = parseField(text, field.dataType);
-    offset += field.fieldLength;
+  var out = {};
+  var offset = 0;
+
+  var _iterator2 = _createForOfIteratorHelper(fields),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var field = _step2.value;
+      var text = textDecoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset, field.fieldLength));
+      out[field.name] = parseField(text, field.dataType);
+      offset += field.fieldLength;
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
   }
 
   return out;
@@ -266,7 +411,7 @@ function parseBoolean(value) {
 }
 
 function parseNumber(text) {
-  const number = parseFloat(text);
+  var number = parseFloat(text);
   return isNaN(number) ? null : number;
 }
 
@@ -274,12 +419,12 @@ function parseCharacter(text) {
   return text.trim() || null;
 }
 
-function makeField({
-  name,
-  dataType,
-  fieldLength,
-  decimal
-}) {
+function makeField(_ref2) {
+  var name = _ref2.name,
+      dataType = _ref2.dataType,
+      fieldLength = _ref2.fieldLength,
+      decimal = _ref2.decimal;
+
   switch (dataType) {
     case 'B':
       return new _schema.Field(name, new _schema.Float64(), true);