@loaders.gl/schema 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/dist.dev.js

@@ -2,14 +2,20 @@
   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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  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 +28,31 @@ 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);
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+
+  // external-global-plugin:@loaders.gl/core
+  var require_core = __commonJS({
+    "external-global-plugin:@loaders.gl/core"(exports, module) {
+      module.exports = globalThis.loaders;
+    }
+  });
 
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
     ArrowLikeDataType: () => DataType,
     ArrowLikeField: () => ArrowLikeField,
     ArrowLikeSchema: () => ArrowLikeSchema,
@@ -95,10 +121,14 @@ var __exports__ = (() => {
     makeTableFromBatches: () => makeTableFromBatches,
     makeTableFromData: () => makeTableFromData
   });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // src/lib/table/batches/base-table-batch-aggregator.ts
   var DEFAULT_ROW_COUNT = 100;
   var BaseTableBatchAggregator = class {
+    schema;
+    options;
+    shape;
     length = 0;
     rows = null;
     cursor = 0;
@@ -199,6 +229,8 @@ var __exports__ = (() => {
   // src/lib/table/batches/row-table-batch-aggregator.ts
   var DEFAULT_ROW_COUNT2 = 100;
   var RowTableBatchAggregator = class {
+    schema;
+    options;
     length = 0;
     objectRows = null;
     arrayRows = null;
@@ -264,6 +296,7 @@ var __exports__ = (() => {
         batchType: "data",
         data: rows,
         length: this.length,
+        // @ts-expect-error we should infer a schema
         schema: this.schema,
         cursor: this.cursor
       };
@@ -273,6 +306,7 @@ var __exports__ = (() => {
   // src/lib/table/batches/columnar-table-batch-aggregator.ts
   var DEFAULT_ROW_COUNT3 = 100;
   var ColumnarTableBatchAggregator = class {
+    schema;
     length = 0;
     allocated = 0;
     columns = {};
@@ -317,6 +351,7 @@ var __exports__ = (() => {
       };
       return batch;
     }
+    // HELPERS
     _reallocateColumns() {
       if (this.length < this.allocated) {
         return;
@@ -355,7 +390,9 @@ var __exports__ = (() => {
     _limitMB: 0
   };
   var ERR_MESSAGE = "TableBatchBuilder";
-  var TableBatchBuilder = class {
+  var _TableBatchBuilder = class {
+    schema;
+    options;
     aggregator = null;
     batchCount = 0;
     bytesUsed = 0;
@@ -366,10 +403,7 @@ var __exports__ = (() => {
     rowBytes = 0;
     constructor(schema, options) {
       this.schema = schema;
-      this.options = {
-        ...DEFAULT_OPTIONS,
-        ...options
-      };
+      this.options = { ...DEFAULT_OPTIONS, ...options };
     }
     limitReached() {
       if (Boolean(this.options?.limit) && this.totalLength >= this.options.limit) {
@@ -380,6 +414,7 @@ var __exports__ = (() => {
       }
       return false;
     }
+    /** @deprecated Use addArrayRow or addObjectRow */
     addRow(row) {
       if (this.limitReached()) {
         return;
@@ -393,6 +428,7 @@ var __exports__ = (() => {
         this.addObjectRow(row);
       }
     }
+    /** Add one row to the batch */
     addArrayRow(row) {
       if (!this.aggregator) {
         const TableBatchType = this._getTableBatchType();
@@ -400,6 +436,7 @@ var __exports__ = (() => {
       }
       this.aggregator.addArrayRow(row);
     }
+    /** Add one row to the batch */
     addObjectRow(row) {
       if (!this.aggregator) {
         const TableBatchType = this._getTableBatchType();
@@ -407,6 +444,7 @@ var __exports__ = (() => {
       }
       this.aggregator.addObjectRow(row);
     }
+    /** Mark an incoming raw memory chunk has completed */
     chunkComplete(chunk) {
       if (chunk instanceof ArrayBuffer) {
         this.bytesUsed += chunk.byteLength;
@@ -422,6 +460,7 @@ var __exports__ = (() => {
     getFinalBatch(options) {
       return this._getBatch(options);
     }
+    // INTERNAL
     _estimateRowMB(row) {
       return Array.isArray(row) ? row.length * 8 : Object.keys(row).length * 8;
     }
@@ -443,6 +482,9 @@ var __exports__ = (() => {
       this.lastBatchEmittedMs = Date.now();
       return true;
     }
+    /**
+     * bytesUsed can be set via chunkComplete or via getBatch*
+     */
     _getBatch(options) {
       if (!this.aggregator) {
         return null;
@@ -466,15 +508,17 @@ var __exports__ = (() => {
         case "columnar-table":
           return ColumnarTableBatchAggregator;
         case "arrow-table":
-          if (!TableBatchBuilder.ArrowBatch) {
+          if (!_TableBatchBuilder.ArrowBatch) {
             throw new Error(ERR_MESSAGE);
           }
-          return TableBatchBuilder.ArrowBatch;
+          return _TableBatchBuilder.ArrowBatch;
         default:
           return BaseTableBatchAggregator;
       }
     }
   };
+  var TableBatchBuilder = _TableBatchBuilder;
+  __publicField(TableBatchBuilder, "ArrowBatch");
 
   // src/lib/table/simple-table/table-accessors.ts
   function isTable(table) {
@@ -549,7 +593,9 @@ var __exports__ = (() => {
         return column[rowIndex];
       case "arrow-table":
         const arrowTable = table.data;
-        const arrowColumnIndex = arrowTable.schema.fields.findIndex((field) => field.name === columnName);
+        const arrowColumnIndex = arrowTable.schema.fields.findIndex(
+          (field) => field.name === columnName
+        );
         return arrowTable.getChildAt(arrowColumnIndex)?.get(rowIndex);
       default:
         throw new Error("todo");
@@ -708,6 +754,10 @@ var __exports__ = (() => {
 
   // src/lib/table/arrow-api/arrow-like-field.ts
   var ArrowLikeField = class {
+    name;
+    type;
+    nullable;
+    metadata;
     constructor(name, type, nullable = false, metadata = /* @__PURE__ */ new Map()) {
       this.name = name;
       this.type = type;
@@ -724,16 +774,21 @@ var __exports__ = (() => {
       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}` : ""}`;
+      return `${JSON.stringify(this.type)}${this.nullable ? ", nullable" : ""}${this.metadata ? `, metadata: ${JSON.stringify(this.metadata)}` : ""}`;
     }
   };
 
   // src/lib/table/arrow-api/arrow-like-schema.ts
   var ArrowLikeSchema = class {
+    fields;
+    metadata;
     constructor(fields, metadata = /* @__PURE__ */ new Map()) {
-      this.fields = fields.map((field) => new ArrowLikeField(field.name, field.type, field.nullable, field.metadata));
+      this.fields = fields.map(
+        (field) => new ArrowLikeField(field.name, field.type, field.nullable, field.metadata)
+      );
       this.metadata = metadata instanceof Map ? metadata : new Map(Object.entries(metadata));
     }
+    // TODO - arrow only seems to compare fields, not metadata
     compareTo(other) {
       if (this.metadata !== other.metadata) {
         return false;
@@ -804,22 +859,13 @@ var __exports__ = (() => {
   function getDataTypeFromArray(array) {
     let type = getDataTypeFromTypedArray(array);
     if (type !== "null") {
-      return {
-        type,
-        nullable: false
-      };
+      return { type, nullable: false };
     }
     if (array.length > 0) {
       type = getDataTypeFromValue(array[0]);
-      return {
-        type,
-        nullable: true
-      };
+      return { type, nullable: true };
     }
-    return {
-      type: "null",
-      nullable: true
-    };
+    return { type: "null", nullable: true };
   }
   function getDataTypeFromTypedArray(array) {
     switch (array.constructor) {
@@ -889,10 +935,7 @@ var __exports__ = (() => {
       const field = deduceFieldFromColumn(column, columnName);
       fields.push(field);
     }
-    return {
-      fields,
-      metadata: {}
-    };
+    return { fields, metadata: {} };
   }
   function deduceSchemaFromRows(rowTable) {
     if (!rowTable.length) {
@@ -903,10 +946,7 @@ var __exports__ = (() => {
     for (const [columnName, value] of Object.entries(row0)) {
       fields.push(deduceFieldFromValue(value, columnName));
     }
-    return {
-      fields,
-      metadata: {}
-    };
+    return { fields, metadata: {} };
   }
   function deduceFieldFromColumn(column, name) {
     if (ArrayBuffer.isView(column)) {
@@ -915,6 +955,7 @@ var __exports__ = (() => {
         name,
         type: type.type || "null",
         nullable: type.nullable
+        // metadata: {}
       };
     }
     if (Array.isArray(column) && column.length > 0) {
@@ -924,6 +965,7 @@ var __exports__ = (() => {
         name,
         type,
         nullable: true
+        // metadata: {},
       };
     }
     throw new Error("empty table");
@@ -934,11 +976,14 @@ var __exports__ = (() => {
       name,
       type,
       nullable: true
+      // metadata: {}
     };
   }
 
   // src/lib/table/arrow-api/arrow-like-table.ts
   var ArrowLikeVector = class {
+    table;
+    columnName;
     constructor(table, columnName) {
       this.table = table;
       this.columnName = columnName;
@@ -959,14 +1004,16 @@ var __exports__ = (() => {
     }
   };
   var ArrowLikeTable = class {
+    schema;
+    table;
     constructor(table) {
       const schema = table.schema || deduceTableSchema(table);
       this.schema = new ArrowLikeSchema(schema.fields, schema.metadata);
-      this.table = {
-        ...table,
-        schema
-      };
+      this.table = { ...table, schema };
     }
+    // get schema() {
+    //   return this.table.schema;
+    // }
     get data() {
       return this.table.shape === "geojson-table" ? this.table.features : this.table.data;
     }
@@ -979,6 +1026,9 @@ var __exports__ = (() => {
     getChild(columnName) {
       return new ArrowLikeVector(this.table, columnName);
     }
+    // getChildAt(columnIndex: number): ArrowLikeVector {
+    //   return
+    // }
   };
 
   // src/lib/table/simple-table/make-table.ts
@@ -986,31 +1036,19 @@ var __exports__ = (() => {
     let table;
     switch (getTableShapeFromData(data)) {
       case "array-row-table":
-        table = {
-          shape: "array-row-table",
-          data
-        };
+        table = { shape: "array-row-table", data };
         break;
       case "object-row-table":
-        table = {
-          shape: "object-row-table",
-          data
-        };
+        table = { shape: "object-row-table", data };
         break;
       case "columnar-table":
-        table = {
-          shape: "columnar-table",
-          data
-        };
+        table = { shape: "columnar-table", data };
         break;
       default:
         throw new Error("table");
     }
     const schema = deduceTableSchema(table);
-    return {
-      ...table,
-      schema
-    };
+    return { ...table, schema };
   }
   function getTableShapeFromData(data) {
     if (Array.isArray(data)) {
@@ -1033,11 +1071,7 @@ var __exports__ = (() => {
 
   // src/lib/table/simple-table/make-table-from-batches.ts
   function makeBatchFromTable(table) {
-    return {
-      ...table,
-      length: getTableLength(table),
-      batchType: "data"
-    };
+    return { ...table, length: getTableLength(table), batchType: "data" };
   }
   async function makeTableFromBatches(batchIterator) {
     let arrayRows;
@@ -1081,24 +1115,11 @@ var __exports__ = (() => {
     }
     switch (shape) {
       case "array-row-table":
-        return {
-          shape: "array-row-table",
-          data: arrayRows,
-          schema
-        };
+        return { shape: "array-row-table", data: arrayRows, schema };
       case "object-row-table":
-        return {
-          shape: "object-row-table",
-          data: objectRows,
-          schema
-        };
+        return { shape: "object-row-table", data: objectRows, schema };
       case "geojson-table":
-        return {
-          shape: "geojson-table",
-          type: "FeatureCollection",
-          features,
-          schema
-        };
+        return { shape: "geojson-table", type: "FeatureCollection", features, schema };
       default:
         return null;
     }
@@ -1136,10 +1157,7 @@ var __exports__ = (() => {
     const schema = table.schema || deduceTableSchema(table);
     const fields = table.schema?.fields || [];
     if (table.shape === "columnar-table") {
-      return {
-        ...table,
-        schema
-      };
+      return { ...table, schema };
     }
     const length = getTableLength(table);
     const columns = {};
@@ -1218,30 +1236,23 @@ var __exports__ = (() => {
       maxY = y > maxY ? y : maxY;
       maxZ = z > maxZ ? z : maxZ;
     }
-    return [[minX, minY, minZ], [maxX, maxY, maxZ]];
+    return [
+      [minX, minY, minZ],
+      [maxX, maxY, maxZ]
+    ];
   }
 
   // src/lib/mesh/deduce-mesh-schema.ts
   function deduceMeshSchema(attributes, metadata = {}) {
     const fields = deduceMeshFields(attributes);
-    return {
-      fields,
-      metadata
-    };
+    return { fields, metadata };
   }
   function deduceMeshField(name, attribute, optionalMetadata) {
     const type = getDataTypeFromTypedArray(attribute.value);
     const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
     return {
       name,
-      type: {
-        type: "fixed-size-list",
-        listSize: attribute.size,
-        children: [{
-          name: "value",
-          type
-        }]
-      },
+      type: { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "value", type }] },
       nullable: false,
       metadata
     };
@@ -1269,7 +1280,7 @@ var __exports__ = (() => {
   }
 
   // src/lib/table/arrow-api/enum.ts
-  var Type = function(Type2) {
+  var Type = /* @__PURE__ */ ((Type2) => {
     Type2[Type2["NONE"] = 0] = "NONE";
     Type2[Type2["Null"] = 1] = "Null";
     Type2[Type2["Int"] = 2] = "Int";
@@ -1315,74 +1326,78 @@ var __exports__ = (() => {
     Type2[Type2["IntervalDayTime"] = -25] = "IntervalDayTime";
     Type2[Type2["IntervalYearMonth"] = -26] = "IntervalYearMonth";
     return Type2;
-  }({});
+  })(Type || {});
 
   // src/lib/table/arrow-api/arrow-like-type.ts
   var DataType = class {
     static isNull(x) {
-      return x && x.typeId === Type.Null;
+      return x && x.typeId === 1 /* Null */;
     }
     static isInt(x) {
-      return x && x.typeId === Type.Int;
+      return x && x.typeId === 2 /* Int */;
     }
     static isFloat(x) {
-      return x && x.typeId === Type.Float;
+      return x && x.typeId === 3 /* Float */;
     }
     static isBinary(x) {
-      return x && x.typeId === Type.Binary;
+      return x && x.typeId === 4 /* Binary */;
     }
     static isUtf8(x) {
-      return x && x.typeId === Type.Utf8;
+      return x && x.typeId === 5 /* Utf8 */;
     }
     static isBool(x) {
-      return x && x.typeId === Type.Bool;
+      return x && x.typeId === 6 /* Bool */;
     }
     static isDecimal(x) {
-      return x && x.typeId === Type.Decimal;
+      return x && x.typeId === 7 /* Decimal */;
     }
     static isDate(x) {
-      return x && x.typeId === Type.Date;
+      return x && x.typeId === 8 /* Date */;
     }
     static isTime(x) {
-      return x && x.typeId === Type.Time;
+      return x && x.typeId === 9 /* Time */;
     }
     static isTimestamp(x) {
-      return x && x.typeId === Type.Timestamp;
+      return x && x.typeId === 10 /* Timestamp */;
     }
     static isInterval(x) {
-      return x && x.typeId === Type.Interval;
+      return x && x.typeId === 11 /* Interval */;
     }
     static isList(x) {
-      return x && x.typeId === Type.List;
+      return x && x.typeId === 12 /* List */;
     }
     static isStruct(x) {
-      return x && x.typeId === Type.Struct;
+      return x && x.typeId === 13 /* Struct */;
     }
     static isUnion(x) {
-      return x && x.typeId === Type.Union;
+      return x && x.typeId === 14 /* Union */;
     }
     static isFixedSizeBinary(x) {
-      return x && x.typeId === Type.FixedSizeBinary;
+      return x && x.typeId === 15 /* FixedSizeBinary */;
     }
     static isFixedSizeList(x) {
-      return x && x.typeId === Type.FixedSizeList;
+      return x && x.typeId === 16 /* FixedSizeList */;
     }
     static isMap(x) {
-      return x && x.typeId === Type.Map;
+      return x && x.typeId === 17 /* Map */;
     }
     static isDictionary(x) {
-      return x && x.typeId === Type.Dictionary;
+      return x && x.typeId === -1 /* Dictionary */;
     }
     get typeId() {
-      return Type.NONE;
+      return 0 /* NONE */;
     }
+    // get ArrayType(): AnyArrayType {
+    //   return Int8Array;
+    // }
+    // get ArrayType() { return Array; }
     compareTo(other) {
       return this === other;
     }
   };
   var Null = class extends DataType {
     get typeId() {
-      return Type.Null;
+      return 1 /* Null */;
     }
     get [Symbol.toStringTag]() {
       return "Null";
@@ -1393,8 +1408,11 @@ var __exports__ = (() => {
   };
   var Bool = class extends DataType {
     get typeId() {
-      return Type.Bool;
+      return 6 /* Bool */;
     }
+    // get ArrayType() {
+    //   return Uint8Array;
+    // }
     get [Symbol.toStringTag]() {
       return "Bool";
     }
@@ -1403,14 +1421,30 @@ var __exports__ = (() => {
     }
   };
   var Int = class extends DataType {
+    isSigned;
+    bitWidth;
     constructor(isSigned, bitWidth) {
       super();
       this.isSigned = isSigned;
       this.bitWidth = bitWidth;
     }
     get typeId() {
-      return Type.Int;
-    }
+      return 2 /* Int */;
+    }
+    // get ArrayType() {
+    //   switch (this.bitWidth) {
+    //     case 8:
+    //       return this.isSigned ? Int8Array : Uint8Array;
+    //     case 16:
+    //       return this.isSigned ? Int16Array : Uint16Array;
+    //     case 32:
+    //       return this.isSigned ? Int32Array : Uint32Array;
+    //     case 64:
+    //       return this.isSigned ? Int32Array : Uint32Array;
+    //     default:
+    //       throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);
+    //   }
+    // }
     get [Symbol.toStringTag]() {
       return "Int";
     }
@@ -1464,13 +1498,26 @@ var __exports__ = (() => {
     DOUBLE: 64
   };
   var Float = class extends DataType {
+    precision;
     constructor(precision) {
       super();
       this.precision = precision;
     }
     get typeId() {
-      return Type.Float;
-    }
+      return 3 /* Float */;
+    }
+    // get ArrayType() {
+    //   switch (this.precision) {
+    //     case Precision.HALF:
+    //       return Uint16Array;
+    //     case Precision.SINGLE:
+    //       return Float32Array;
+    //     case Precision.DOUBLE:
+    //       return Float64Array;
+    //     default:
+    //       throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);
+    //   }
+    // }
     get [Symbol.toStringTag]() {
       return "Float";
     }
@@ -1498,7 +1545,7 @@ var __exports__ = (() => {
       super();
     }
     get typeId() {
-      return Type.Binary;
+      return 4 /* Binary */;
     }
     toString() {
       return "Binary";
@@ -1509,8 +1556,11 @@ var __exports__ = (() => {
   };
   var Utf8 = class extends DataType {
     get typeId() {
-      return Type.Utf8;
+      return 5 /* Utf8 */;
     }
+    // get ArrayType() {
+    //   return Uint8Array;
+    // }
     get [Symbol.toStringTag]() {
       return "Utf8";
     }
@@ -1523,13 +1573,17 @@ var __exports__ = (() => {
     MILLISECOND: 1
   };
   var Date2 = class extends DataType {
+    unit;
     constructor(unit) {
       super();
       this.unit = unit;
     }
     get typeId() {
-      return Type.Date;
+      return 8 /* Date */;
     }
+    // get ArrayType() {
+    //   return Int32Array;
+    // }
     get [Symbol.toStringTag]() {
       return "Date";
     }
@@ -1554,13 +1608,15 @@ var __exports__ = (() => {
     NANOSECOND: 1e9
   };
   var Time = class extends DataType {
+    unit;
+    bitWidth;
     constructor(unit, bitWidth) {
       super();
       this.unit = unit;
       this.bitWidth = bitWidth;
     }
     get typeId() {
-      return Type.Time;
+      return 9 /* Time */;
     }
     toString() {
       return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`;
@@ -1568,6 +1624,9 @@ var __exports__ = (() => {
     get [Symbol.toStringTag]() {
       return "Time";
     }
+    // get ArrayType() {
+    //   return Int32Array;
+    // }
   };
   var TimeSecond = class extends Time {
     constructor() {
@@ -1580,14 +1639,19 @@ var __exports__ = (() => {
     }
   };
   var Timestamp = class extends DataType {
+    unit;
+    timezone;
     constructor(unit, timezone = null) {
       super();
       this.unit = unit;
       this.timezone = timezone;
     }
     get typeId() {
-      return Type.Timestamp;
+      return 10 /* Timestamp */;
     }
+    // get ArrayType() {
+    //   return Int32Array;
+    // }
     get [Symbol.toStringTag]() {
       return "Timestamp";
     }
@@ -1620,13 +1684,17 @@ var __exports__ = (() => {
     YEAR_MONTH: 1
   };
   var Interval = class extends DataType {
+    unit;
     constructor(unit) {
       super();
       this.unit = unit;
     }
     get typeId() {
-      return Type.Interval;
+      return 11 /* Interval */;
     }
+    // get ArrayType() {
+    //   return Int32Array;
+    // }
     get [Symbol.toStringTag]() {
       return "Interval";
     }
@@ -1645,13 +1713,15 @@ var __exports__ = (() => {
     }
   };
   var FixedSizeList = class extends DataType {
+    listSize;
+    children;
     constructor(listSize, child) {
       super();
       this.listSize = listSize;
       this.children = [child];
     }
     get typeId() {
-      return Type.FixedSizeList;
+      return 16 /* FixedSizeList */;
     }
     get valueType() {
       return this.children[0].type;
@@ -1659,23 +1729,27 @@ var __exports__ = (() => {
     get valueField() {
       return this.children[0];
     }
+    // get ArrayType() {
+    //   return this.valueType.ArrayType;
+    // }
     get [Symbol.toStringTag]() {
       return "FixedSizeList";
     }
     toString() {
-      return `FixedSizeList[${this.listSize}]<${this.valueType}>`;
+      return `FixedSizeList[${this.listSize}]<${JSON.stringify(this.valueType)}>`;
     }
   };
   var Struct = class extends DataType {
+    children;
     constructor(children) {
       super();
       this.children = children;
     }
     get typeId() {
-      return Type.Struct;
+      return 13 /* Struct */;
     }
     toString() {
-      return `Struct<{${this.children.map((f) => `${f.name}:${f.type}`).join(", ")}}>`;
+      return `Struct<{${this.children.map((f) => `${f.name}:${JSON.stringify(f.type)}`).join(", ")}}>`;
     }
     get [Symbol.toStringTag]() {
       return "Struct";
@@ -1713,6 +1787,9 @@ var __exports__ = (() => {
     }
   };
   var AsyncQueue = class {
+    _values;
+    _settlers;
+    _closed;
     constructor() {
       this._values = new ArrayQueue();
       this._settlers = new ArrayQueue();
@@ -1720,9 +1797,7 @@ var __exports__ = (() => {
     }
     close() {
       while (this._settlers.length > 0) {
-        this._settlers.dequeue().resolve({
-          done: true
-        });
+        this._settlers.dequeue().resolve({ done: true });
       }
       this._closed = true;
     }
@@ -1741,41 +1816,35 @@ var __exports__ = (() => {
         if (value instanceof Error) {
           settler.reject(value);
         } else {
-          settler.resolve({
-            value
-          });
+          settler.resolve({ value });
         }
       } else {
         this._values.enqueue(value);
       }
     }
+    /**
+     * @returns a Promise for an IteratorResult
+     */
     next() {
       if (this._values.length > 0) {
         const value = this._values.dequeue();
         if (value instanceof Error) {
           return Promise.reject(value);
         }
-        return Promise.resolve({
-          value
-        });
+        return Promise.resolve({ value });
       }
       if (this._closed) {
         if (this._settlers.length > 0) {
           throw new Error("Illegal internal state");
         }
-        return Promise.resolve({
-          done: true
-        });
+        return Promise.resolve({ done: true });
       }
       return new Promise((resolve, reject) => {
-        this._settlers.enqueue({
-          resolve,
-          reject
-        });
+        this._settlers.enqueue({ resolve, reject });
       });
     }
   };
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
       return __exports__;
       });