@loaders.gl/shapefile 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/dist.min.js

@@ -155,7 +155,7 @@
 
   // src/lib/parsers/parse-shp-geometry.ts
   function parseRecord(view, options) {
-    const { _maxDimensions } = options?.shp || {};
+    const { _maxDimensions = 4 } = options?.shp || {};
     let offset = 0;
     const type = view.getInt32(offset, LITTLE_ENDIAN2);
     offset += Int32Array.BYTES_PER_ELEMENT;
@@ -390,7 +390,7 @@
                 binaryReader.rewind(SHP_RECORD_HEADER_SIZE);
                 return state;
               }
-              const invalidRecord = recordHeader.byteLength < 4 || recordHeader.type !== result.header.type || recordHeader.recordNumber !== result.currentIndex;
+              const invalidRecord = recordHeader.byteLength < 4 || recordHeader.type !== result.header?.type || recordHeader.recordNumber !== result.currentIndex;
               if (invalidRecord) {
                 binaryReader.rewind(SHP_RECORD_HEADER_SIZE - 4);
               } else {
@@ -440,7 +440,13 @@
           this.binaryReader = new BinaryChunkReader({ maxRewindBytes: SHP_RECORD_HEADER_SIZE });
           this.state = STATE.EXPECTING_HEADER;
           this.result = {
-            geometries: []
+            geometries: [],
+            progress: {
+              bytesTotal: NaN,
+              bytesUsed: NaN,
+              rows: NaN
+            },
+            currentIndex: NaN
           };
           this.options = options;
         }
@@ -492,6 +498,72 @@
     }
   });
 
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+  var init_typeof = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/typeof.js"() {
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+  var init_toPrimitive = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js"() {
+      init_typeof();
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+  var init_toPropertyKey = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js"() {
+      init_typeof();
+      init_toPrimitive();
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  var init_defineProperty = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/defineProperty.js"() {
+      init_toPropertyKey();
+    }
+  });
+
   // ../gis/src/lib/binary-to-geojson.ts
   function binaryToGeometry(data, startIndex, endIndex) {
     switch (data.type) {
@@ -863,7 +935,7 @@
       ENDED = -1;
       whitespace = /\s/;
       latin = /[A-Za-z]/;
-      keyword = /[A-Za-z84]/;
+      keyword = /[A-Za-z84_]/;
       endThings = /[,\]]/;
       digets = /[\d\.E\-\+]/;
       Parser.prototype.readCharicter = function() {
@@ -1150,15 +1222,14 @@
     if (wkt.AXIS) {
       var axisOrder = "";
       for (var i = 0, ii = wkt.AXIS.length; i < ii; ++i) {
-        var axis = wkt.AXIS[i];
-        var descriptor = axis[0].toLowerCase();
-        if (descriptor.indexOf("north") !== -1) {
+        var axis = [wkt.AXIS[i][0].toLowerCase(), wkt.AXIS[i][1].toLowerCase()];
+        if (axis[0].indexOf("north") !== -1 || (axis[0] === "y" || axis[0] === "lat") && axis[1] === "north") {
           axisOrder += "n";
-        } else if (descriptor.indexOf("south") !== -1) {
+        } else if (axis[0].indexOf("south") !== -1 || (axis[0] === "y" || axis[0] === "lat") && axis[1] === "south") {
           axisOrder += "s";
-        } else if (descriptor.indexOf("east") !== -1) {
+        } else if (axis[0].indexOf("east") !== -1 || (axis[0] === "x" || axis[0] === "lon") && axis[1] === "east") {
           axisOrder += "e";
-        } else if (descriptor.indexOf("west") !== -1) {
+        } else if (axis[0].indexOf("west") !== -1 || (axis[0] === "x" || axis[0] === "lon") && axis[1] === "west") {
           axisOrder += "w";
         }
       }
@@ -1254,12 +1325,22 @@
     };
     var list = [
       ["standard_parallel_1", "Standard_Parallel_1"],
+      ["standard_parallel_1", "Latitude of 1st standard parallel"],
       ["standard_parallel_2", "Standard_Parallel_2"],
+      ["standard_parallel_2", "Latitude of 2nd standard parallel"],
       ["false_easting", "False_Easting"],
+      ["false_easting", "False easting"],
+      ["false-easting", "Easting at false origin"],
       ["false_northing", "False_Northing"],
+      ["false_northing", "False northing"],
+      ["false_northing", "Northing at false origin"],
       ["central_meridian", "Central_Meridian"],
+      ["central_meridian", "Longitude of natural origin"],
+      ["central_meridian", "Longitude of false origin"],
       ["latitude_of_origin", "Latitude_Of_Origin"],
       ["latitude_of_origin", "Central_Parallel"],
+      ["latitude_of_origin", "Latitude of natural origin"],
+      ["latitude_of_origin", "Latitude of false origin"],
       ["scale_factor", "Scale_Factor"],
       ["k0", "scale_factor"],
       ["latitude_of_center", "Latitude_Of_Center"],
@@ -6528,6 +6609,7 @@
   var Proj4Projection;
   var init_proj4_projection = __esm({
     "../../node_modules/@math.gl/proj4/dist/esm/lib/proj4-projection.js"() {
+      init_defineProperty();
       init_lib();
       Proj4Projection = class {
         static defineProjectionAliases(aliases) {
@@ -6541,12 +6623,19 @@
           from = "WGS84",
           to = "WGS84"
         }) {
-          const projection = lib_default(from, to);
-          if (!projection) {
+          _defineProperty(this, "_projection", void 0);
+          this._projection = lib_default(from, to);
+          if (!this._projection) {
             throw new Error("Invalid projection");
           }
-          this.project = projection.forward;
-          this.unproject = projection.inverse;
+          this.project = this.project.bind(this);
+          this.unproject = this.unproject.bind(this);
+        }
+        project(coord) {
+          return this._projection.forward(coord);
+        }
+        unproject(coord) {
+          return this._projection.inverse(coord);
         }
       };
     }
@@ -6628,472 +6717,23 @@
     }
   });
 
-  // ../schema/src/lib/utils/assert.ts
-  function assert(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loader assertion failed.");
-    }
-  }
-  var init_assert = __esm({
-    "../schema/src/lib/utils/assert.ts"() {
-    }
-  });
-
-  // ../schema/src/lib/schema/impl/schema.ts
-  function checkNames(fields) {
-    const usedNames = {};
-    for (const field of fields) {
-      if (usedNames[field.name]) {
-        console.warn("Schema: duplicated field name", field.name, field);
-      }
-      usedNames[field.name] = true;
-    }
-  }
-  function mergeMaps(m1, m2) {
-    return new Map([...m1 || new Map(), ...m2 || new Map()]);
-  }
-  var Schema;
-  var init_schema = __esm({
-    "../schema/src/lib/schema/impl/schema.ts"() {
-      init_assert();
-      Schema = class {
-        constructor(fields, metadata) {
-          assert(Array.isArray(fields));
-          checkNames(fields);
-          this.fields = fields;
-          this.metadata = metadata || new Map();
-        }
-        compareTo(other) {
-          if (this.metadata !== other.metadata) {
-            return false;
-          }
-          if (this.fields.length !== other.fields.length) {
-            return false;
-          }
-          for (let i = 0; i < this.fields.length; ++i) {
-            if (!this.fields[i].compareTo(other.fields[i])) {
-              return false;
-            }
-          }
-          return true;
-        }
-        select(...columnNames) {
-          const nameMap = Object.create(null);
-          for (const name of columnNames) {
-            nameMap[name] = true;
-          }
-          const selectedFields = this.fields.filter((field) => nameMap[field.name]);
-          return new Schema(selectedFields, this.metadata);
-        }
-        selectAt(...columnIndices) {
-          const selectedFields = columnIndices.map((index) => this.fields[index]).filter(Boolean);
-          return new Schema(selectedFields, this.metadata);
-        }
-        assign(schemaOrFields) {
-          let fields;
-          let metadata = this.metadata;
-          if (schemaOrFields instanceof Schema) {
-            const otherSchema = schemaOrFields;
-            fields = otherSchema.fields;
-            metadata = mergeMaps(mergeMaps(new Map(), this.metadata), otherSchema.metadata);
-          } else {
-            fields = schemaOrFields;
-          }
-          const fieldMap = Object.create(null);
-          for (const field of this.fields) {
-            fieldMap[field.name] = field;
-          }
-          for (const field of fields) {
-            fieldMap[field.name] = field;
-          }
-          const mergedFields = Object.values(fieldMap);
-          return new Schema(mergedFields, metadata);
-        }
-      };
-    }
-  });
-
-  // ../schema/src/lib/schema/impl/field.ts
-  var Field;
-  var init_field = __esm({
-    "../schema/src/lib/schema/impl/field.ts"() {
-      Field = class {
-        constructor(name, type, nullable = false, metadata = new Map()) {
-          this.name = name;
-          this.type = type;
-          this.nullable = nullable;
-          this.metadata = metadata;
-        }
-        get typeId() {
-          return this.type && this.type.typeId;
-        }
-        clone() {
-          return new Field(this.name, this.type, this.nullable, this.metadata);
-        }
-        compareTo(other) {
-          return this.name === other.name && this.type === other.type && this.nullable === other.nullable && this.metadata === other.metadata;
-        }
-        toString() {
-          return `${this.type}${this.nullable ? ", nullable" : ""}${this.metadata ? `, metadata: ${this.metadata}` : ""}`;
-        }
-      };
-    }
-  });
-
-  // ../schema/src/lib/schema/impl/enum.ts
-  var Type;
-  var init_enum = __esm({
-    "../schema/src/lib/schema/impl/enum.ts"() {
-      (function(Type2) {
-        Type2[Type2["NONE"] = 0] = "NONE";
-        Type2[Type2["Null"] = 1] = "Null";
-        Type2[Type2["Int"] = 2] = "Int";
-        Type2[Type2["Float"] = 3] = "Float";
-        Type2[Type2["Binary"] = 4] = "Binary";
-        Type2[Type2["Utf8"] = 5] = "Utf8";
-        Type2[Type2["Bool"] = 6] = "Bool";
-        Type2[Type2["Decimal"] = 7] = "Decimal";
-        Type2[Type2["Date"] = 8] = "Date";
-        Type2[Type2["Time"] = 9] = "Time";
-        Type2[Type2["Timestamp"] = 10] = "Timestamp";
-        Type2[Type2["Interval"] = 11] = "Interval";
-        Type2[Type2["List"] = 12] = "List";
-        Type2[Type2["Struct"] = 13] = "Struct";
-        Type2[Type2["Union"] = 14] = "Union";
-        Type2[Type2["FixedSizeBinary"] = 15] = "FixedSizeBinary";
-        Type2[Type2["FixedSizeList"] = 16] = "FixedSizeList";
-        Type2[Type2["Map"] = 17] = "Map";
-        Type2[Type2["Dictionary"] = -1] = "Dictionary";
-        Type2[Type2["Int8"] = -2] = "Int8";
-        Type2[Type2["Int16"] = -3] = "Int16";
-        Type2[Type2["Int32"] = -4] = "Int32";
-        Type2[Type2["Int64"] = -5] = "Int64";
-        Type2[Type2["Uint8"] = -6] = "Uint8";
-        Type2[Type2["Uint16"] = -7] = "Uint16";
-        Type2[Type2["Uint32"] = -8] = "Uint32";
-        Type2[Type2["Uint64"] = -9] = "Uint64";
-        Type2[Type2["Float16"] = -10] = "Float16";
-        Type2[Type2["Float32"] = -11] = "Float32";
-        Type2[Type2["Float64"] = -12] = "Float64";
-        Type2[Type2["DateDay"] = -13] = "DateDay";
-        Type2[Type2["DateMillisecond"] = -14] = "DateMillisecond";
-        Type2[Type2["TimestampSecond"] = -15] = "TimestampSecond";
-        Type2[Type2["TimestampMillisecond"] = -16] = "TimestampMillisecond";
-        Type2[Type2["TimestampMicrosecond"] = -17] = "TimestampMicrosecond";
-        Type2[Type2["TimestampNanosecond"] = -18] = "TimestampNanosecond";
-        Type2[Type2["TimeSecond"] = -19] = "TimeSecond";
-        Type2[Type2["TimeMillisecond"] = -20] = "TimeMillisecond";
-        Type2[Type2["TimeMicrosecond"] = -21] = "TimeMicrosecond";
-        Type2[Type2["TimeNanosecond"] = -22] = "TimeNanosecond";
-        Type2[Type2["DenseUnion"] = -23] = "DenseUnion";
-        Type2[Type2["SparseUnion"] = -24] = "SparseUnion";
-        Type2[Type2["IntervalDayTime"] = -25] = "IntervalDayTime";
-        Type2[Type2["IntervalYearMonth"] = -26] = "IntervalYearMonth";
-      })(Type || (Type = {}));
-    }
-  });
-
-  // ../schema/src/lib/schema/impl/type.ts
-  var DataType, Null, Bool, Int, Precision, Float, Float64, Binary, Utf8, DateUnit, Date2, TimeUnit, Time, Timestamp, TimestampMillisecond, IntervalUnit, Interval, FixedSizeList, Struct;
-  var init_type = __esm({
-    "../schema/src/lib/schema/impl/type.ts"() {
-      init_enum();
-      DataType = class {
-        static isNull(x) {
-          return x && x.typeId === Type.Null;
-        }
-        static isInt(x) {
-          return x && x.typeId === Type.Int;
-        }
-        static isFloat(x) {
-          return x && x.typeId === Type.Float;
-        }
-        static isBinary(x) {
-          return x && x.typeId === Type.Binary;
-        }
-        static isUtf8(x) {
-          return x && x.typeId === Type.Utf8;
-        }
-        static isBool(x) {
-          return x && x.typeId === Type.Bool;
-        }
-        static isDecimal(x) {
-          return x && x.typeId === Type.Decimal;
-        }
-        static isDate(x) {
-          return x && x.typeId === Type.Date;
-        }
-        static isTime(x) {
-          return x && x.typeId === Type.Time;
-        }
-        static isTimestamp(x) {
-          return x && x.typeId === Type.Timestamp;
-        }
-        static isInterval(x) {
-          return x && x.typeId === Type.Interval;
-        }
-        static isList(x) {
-          return x && x.typeId === Type.List;
-        }
-        static isStruct(x) {
-          return x && x.typeId === Type.Struct;
-        }
-        static isUnion(x) {
-          return x && x.typeId === Type.Union;
-        }
-        static isFixedSizeBinary(x) {
-          return x && x.typeId === Type.FixedSizeBinary;
-        }
-        static isFixedSizeList(x) {
-          return x && x.typeId === Type.FixedSizeList;
-        }
-        static isMap(x) {
-          return x && x.typeId === Type.Map;
-        }
-        static isDictionary(x) {
-          return x && x.typeId === Type.Dictionary;
-        }
-        get typeId() {
-          return Type.NONE;
-        }
-        compareTo(other) {
-          return this === other;
-        }
-      };
-      Null = class extends DataType {
-        get typeId() {
-          return Type.Null;
-        }
-        get [Symbol.toStringTag]() {
-          return "Null";
-        }
-        toString() {
-          return "Null";
-        }
-      };
-      Bool = class extends DataType {
-        get typeId() {
-          return Type.Bool;
-        }
-        get [Symbol.toStringTag]() {
-          return "Bool";
-        }
-        toString() {
-          return "Bool";
-        }
-      };
-      Int = class extends DataType {
-        constructor(isSigned, bitWidth) {
-          super();
-          this.isSigned = isSigned;
-          this.bitWidth = bitWidth;
-        }
-        get typeId() {
-          return Type.Int;
-        }
-        get [Symbol.toStringTag]() {
-          return "Int";
-        }
-        toString() {
-          return `${this.isSigned ? "I" : "Ui"}nt${this.bitWidth}`;
-        }
-      };
-      Precision = {
-        HALF: 16,
-        SINGLE: 32,
-        DOUBLE: 64
-      };
-      Float = class extends DataType {
-        constructor(precision) {
-          super();
-          this.precision = precision;
-        }
-        get typeId() {
-          return Type.Float;
-        }
-        get [Symbol.toStringTag]() {
-          return "Float";
-        }
-        toString() {
-          return `Float${this.precision}`;
-        }
-      };
-      Float64 = class extends Float {
-        constructor() {
-          super(Precision.DOUBLE);
-        }
-      };
-      Binary = class extends DataType {
-        constructor() {
-          super();
-        }
-        get typeId() {
-          return Type.Binary;
-        }
-        toString() {
-          return "Binary";
-        }
-        get [Symbol.toStringTag]() {
-          return "Binary";
-        }
-      };
-      Utf8 = class extends DataType {
-        get typeId() {
-          return Type.Utf8;
-        }
-        get [Symbol.toStringTag]() {
-          return "Utf8";
-        }
-        toString() {
-          return "Utf8";
-        }
-      };
-      DateUnit = {
-        DAY: 0,
-        MILLISECOND: 1
-      };
-      Date2 = class extends DataType {
-        constructor(unit) {
-          super();
-          this.unit = unit;
-        }
-        get typeId() {
-          return Type.Date;
-        }
-        get [Symbol.toStringTag]() {
-          return "Date";
-        }
-        toString() {
-          return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;
-        }
-      };
-      TimeUnit = {
-        SECOND: 1,
-        MILLISECOND: 1e3,
-        MICROSECOND: 1e6,
-        NANOSECOND: 1e9
-      };
-      Time = class extends DataType {
-        constructor(unit, bitWidth) {
-          super();
-          this.unit = unit;
-          this.bitWidth = bitWidth;
-        }
-        get typeId() {
-          return Type.Time;
-        }
-        toString() {
-          return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`;
-        }
-        get [Symbol.toStringTag]() {
-          return "Time";
-        }
-      };
-      Timestamp = class extends DataType {
-        constructor(unit, timezone = null) {
-          super();
-          this.unit = unit;
-          this.timezone = timezone;
-        }
-        get typeId() {
-          return Type.Timestamp;
-        }
-        get [Symbol.toStringTag]() {
-          return "Timestamp";
-        }
-        toString() {
-          return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ""}>`;
-        }
-      };
-      TimestampMillisecond = class extends Timestamp {
-        constructor(timezone = null) {
-          super(TimeUnit.MILLISECOND, timezone);
-        }
-      };
-      IntervalUnit = {
-        DAY_TIME: 0,
-        YEAR_MONTH: 1
-      };
-      Interval = class extends DataType {
-        constructor(unit) {
-          super();
-          this.unit = unit;
-        }
-        get typeId() {
-          return Type.Interval;
-        }
-        get [Symbol.toStringTag]() {
-          return "Interval";
-        }
-        toString() {
-          return `Interval<${IntervalUnit[this.unit]}>`;
-        }
-      };
-      FixedSizeList = class extends DataType {
-        constructor(listSize, child) {
-          super();
-          this.listSize = listSize;
-          this.children = [child];
-        }
-        get typeId() {
-          return Type.FixedSizeList;
-        }
-        get valueType() {
-          return this.children[0].type;
-        }
-        get valueField() {
-          return this.children[0];
-        }
-        get [Symbol.toStringTag]() {
-          return "FixedSizeList";
-        }
-        toString() {
-          return `FixedSizeList[${this.listSize}]<${this.valueType}>`;
-        }
-      };
-      Struct = class extends DataType {
-        constructor(children) {
-          super();
-          this.children = children;
-        }
-        get typeId() {
-          return Type.Struct;
-        }
-        toString() {
-          return `Struct<{${this.children.map((f) => `${f.name}:${f.type}`).join(", ")}}>`;
-        }
-        get [Symbol.toStringTag]() {
-          return "Struct";
-        }
-      };
-    }
-  });
-
-  // ../schema/src/lib/schema/schema.ts
-  var init_schema2 = __esm({
-    "../schema/src/lib/schema/schema.ts"() {
-      init_schema();
-      init_field();
-      init_type();
-    }
-  });
-
-  // ../schema/src/index.ts
-  var init_src2 = __esm({
-    "../schema/src/index.ts"() {
-      init_schema2();
-    }
-  });
-
   // src/lib/parsers/parse-dbf.ts
   function parseDBF(arrayBuffer, options = {}) {
-    const loaderOptions = options.dbf || {};
-    const { encoding } = loaderOptions;
+    const { encoding = "latin1" } = options.dbf || {};
     const dbfParser = new DBFParser({ encoding });
     dbfParser.write(arrayBuffer);
     dbfParser.end();
     const { data, schema } = dbfParser.result;
-    switch (options.tables && options.tables.format) {
+    const shape = options?.tables?.format || options?.dbf?.shape;
+    switch (shape) {
+      case "object-row-table": {
+        const table = {
+          shape: "object-row-table",
+          schema,
+          data
+        };
+        return table;
+      }
       case "table":
         return { schema, rows: data };
       case "rows":
@@ -7102,8 +6742,7 @@
     }
   }
   async function* parseDBFInBatches(asyncIterator, options = {}) {
-    const loaderOptions = options.dbf || {};
-    const { encoding } = loaderOptions;
+    const { encoding = "latin1" } = options.dbf || {};
     const parser = new DBFParser({ encoding });
     let headerReturned = false;
     for await (const arrayBuffer of asyncIterator) {
@@ -7130,7 +6769,7 @@
           case 3:
             return state;
           case 0:
-            const dataView = binaryReader.getDataView(DBF_HEADER_SIZE, "DBF header");
+            const dataView = binaryReader.getDataView(DBF_HEADER_SIZE);
             if (!dataView) {
               return state;
             }
@@ -7143,12 +6782,15 @@
             state = 1;
             break;
           case 1:
-            const fieldDescriptorView = binaryReader.getDataView(result.dbfHeader.headerLength - DBF_HEADER_SIZE, "DBF field descriptors");
+            const fieldDescriptorView = binaryReader.getDataView(result.dbfHeader.headerLength - DBF_HEADER_SIZE);
             if (!fieldDescriptorView) {
               return state;
             }
             result.dbfFields = parseFieldDescriptors(fieldDescriptorView, textDecoder);
-            result.schema = new Schema(result.dbfFields.map((dbfField) => makeField(dbfField)));
+            result.schema = {
+              fields: result.dbfFields.map((dbfField) => makeField(dbfField)),
+              metadata: {}
+            };
             state = 2;
             binaryReader.skip(1);
             break;
@@ -7251,19 +6893,19 @@
   function makeField({ name, dataType, fieldLength, decimal }) {
     switch (dataType) {
       case "B":
-        return new Field(name, new Float64(), true);
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "C":
-        return new Field(name, new Utf8(), true);
+        return { name, type: "utf8", nullable: true, metadata: {} };
       case "F":
-        return new Field(name, new Float64(), true);
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "N":
-        return new Field(name, new Float64(), true);
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "O":
-        return new Field(name, new Float64(), true);
+        return { name, type: "float64", nullable: true, metadata: {} };
       case "D":
-        return new Field(name, new TimestampMillisecond(), true);
+        return { name, type: "timestamp-millisecond", nullable: true, metadata: {} };
       case "L":
-        return new Field(name, new Bool(), true);
+        return { name, type: "bool", nullable: true, metadata: {} };
       default:
         throw new Error("Unsupported data type");
     }
@@ -7271,7 +6913,6 @@
   var LITTLE_ENDIAN4, DBF_HEADER_SIZE, STATE2, DBFParser;
   var init_parse_dbf = __esm({
     "src/lib/parsers/parse-dbf.ts"() {
-      init_src2();
       init_binary_chunk_reader();
       LITTLE_ENDIAN4 = true;
       DBF_HEADER_SIZE = 32;
@@ -7537,7 +7178,7 @@
     SHPWorkerLoader: () => SHPWorkerLoader,
     ShapefileLoader: () => ShapefileLoader
   });
-  var init_src3 = __esm({
+  var init_src2 = __esm({
     "src/index.ts"() {
       init_shapefile_loader();
       init_dbf_loader();
@@ -7548,7 +7189,7 @@
   // src/bundle.ts
   var require_bundle = __commonJS({
     "src/bundle.ts"(exports4, module) {
-      var moduleExports = (init_src3(), src_exports);
+      var moduleExports = (init_src2(), src_exports);
       globalThis.loaders = globalThis.loaders || {};
       module.exports = Object.assign(globalThis.loaders, moduleExports);
     }