@nika-js/onlymap 0.3.0 → 0.3.2

package/dist/index-CDvm17M5.js

@@ -0,0 +1,1446 @@
+import { ae as Be, af as le, ag as ce, ah as De, ai as Oe, aj as ke } from "./index-DYtODPDb.js";
+import { y as ve, a as he, z as G, R as J, A as ue, C as Fe, F as je, n as xe, S as Ie, E as Ne } from "./recordbatch-Bpc0uxFn.js";
+import { g as V, a as fe, b as Le, c as Ue, d as Me, e as qe, m as Ve } from "./table-accessors-CYWTzpQI.js";
+import { c as $e } from "./convert-arrow-schema-DrAihRf9.js";
+function de(t) {
+  switch (t.shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return Pe(t.data);
+    case "geojson-table":
+      return ze(t.features);
+    case "columnar-table":
+      return He(t.data);
+    case "arrow-table":
+    default:
+      throw new Error("Deduce schema");
+  }
+}
+function He(t) {
+  const e = [];
+  for (const [r, s] of Object.entries(t)) {
+    const n = Qe(s, r);
+    e.push(n);
+  }
+  return { fields: e, metadata: {} };
+}
+function Pe(t) {
+  if (!t.length)
+    throw new Error("deduce from empty table");
+  const e = [], r = t[0];
+  for (const [s, n] of Object.entries(r))
+    e.push(me(n, s));
+  return { fields: e, metadata: {} };
+}
+function ze(t) {
+  if (!t.length)
+    throw new Error("deduce from empty table");
+  const e = [], r = t[0].properties || {};
+  for (const [s, n] of Object.entries(r))
+    e.push(me(n, s));
+  return { fields: e, metadata: {} };
+}
+function Qe(t, e) {
+  if (ArrayBuffer.isView(t)) {
+    const r = Be(t);
+    return {
+      name: e,
+      type: r.type || "null",
+      nullable: r.nullable
+      // metadata: {}
+    };
+  }
+  if (Array.isArray(t) && t.length > 0) {
+    const r = t[0], s = le(r);
+    return {
+      name: e,
+      type: s,
+      nullable: !0
+      // metadata: {},
+    };
+  }
+  throw new Error("empty table");
+}
+function me(t, e) {
+  const r = le(t);
+  return {
+    name: e,
+    type: r,
+    nullable: !0
+    // metadata: {}
+  };
+}
+function Je(t, e) {
+  const r = ce(t.type, t.nullable);
+  return new r(e);
+}
+function* We(t, e) {
+  const r = $e(t.schema), s = V(t), n = fe(t), a = s, c = r?.fields.map((o) => ve(o)), h = new he(r.fields);
+  let f = 0;
+  for (let o = 0; o < s; o++)
+    for (let u = 0; u < n; ++u) {
+      const i = Le(t, o, u);
+      if (c[u].append(i), f++, f >= a) {
+        const g = c.map((l) => l.flush()), w = new G(h, 0, f, 0, void 0, g);
+        yield new J(r, w), f = 0;
+      }
+    }
+  if (f > 0) {
+    const o = c.map((i) => i.flush()), u = new G(h, 0, f, 0, void 0, o);
+    yield new J(r, u), f = 0;
+  }
+  c.map((o) => o.finish());
+}
+function Ze(t, e) {
+  switch (t.shape) {
+    case "arrow-table":
+      return t.data;
+    case "columnar-table":
+    // TODO - optimized implementation is possible
+    // return convertColumnarTableToArrow(table, options);
+    // fall through
+    default:
+      const r = We(t);
+      return new ue(r);
+  }
+}
+function L(t, e) {
+  switch (e) {
+    case "object-row-table":
+      return Ge(t);
+    case "array-row-table":
+      return Ye(t);
+    case "columnar-table":
+      return Ke(t);
+    case "arrow-table":
+      return Xe(t);
+    default:
+      throw new Error(e);
+  }
+}
+function Ke(t) {
+  const e = t.schema || de(t), r = t.schema?.fields || [];
+  if (t.shape === "columnar-table")
+    return { ...t, schema: e };
+  const s = V(t), n = {};
+  for (const a of r) {
+    const c = Je(a, s);
+    n[a.name] = c;
+    for (let h = 0; h < s; h++)
+      c[h] = Ue(t, h, a.name);
+  }
+  return {
+    shape: "columnar-table",
+    schema: e,
+    data: n
+  };
+}
+function Ye(t) {
+  if (t.shape === "array-row-table")
+    return t;
+  const e = V(t), r = new Array(e);
+  for (let s = 0; s < e; s++)
+    r[s] = Me(t, s);
+  return {
+    shape: "array-row-table",
+    schema: t.schema,
+    data: r
+  };
+}
+function Ge(t) {
+  if (t.shape === "object-row-table")
+    return t;
+  const e = V(t), r = new Array(e);
+  for (let s = 0; s < e; s++)
+    r[s] = qe(t, s);
+  return {
+    shape: "object-row-table",
+    schema: t.schema,
+    data: r
+  };
+}
+function Xe(t) {
+  const e = Ze(t);
+  return {
+    shape: "arrow-table",
+    schema: t.schema,
+    data: e
+  };
+}
+function pe(t, e) {
+  if (!t)
+    throw new Error("null row");
+  const r = {};
+  if (e)
+    for (let s = 0; s < e.length; s++)
+      r[e[s]] = t[s];
+  else
+    for (let s = 0; s < t.length; s++) {
+      const n = `column-${s}`;
+      r[n] = t[s];
+    }
+  return r;
+}
+function ge(t, e) {
+  if (!t)
+    throw new Error("null row");
+  if (e) {
+    const r = new Array(e.length);
+    for (let s = 0; s < e.length; s++)
+      r[s] = t[e[s]];
+    return r;
+  }
+  return Object.values(t);
+}
+function et(t) {
+  const e = [];
+  for (let r = 0; r < t.length; r++) {
+    const s = `column-${r}`;
+    e.push(s);
+  }
+  return e;
+}
+function tt(t) {
+  return Object.keys(t);
+}
+function M(t, e) {
+  switch (e) {
+    case "object-row-table":
+      return { ...t, ...L(t, "object-row-table") };
+    case "array-row-table":
+      return { ...t, ...L(t, "array-row-table") };
+    case "columnar-table":
+      return { ...t, ...L(t, "columnar-table") };
+    case "arrow-table":
+      return { ...t, ...L(t, "arrow-table") };
+    default:
+      throw new Error(e);
+  }
+}
+async function* rt(t, e) {
+  for await (const r of t)
+    switch (e) {
+      case "object-row-table":
+        yield M(r, "object-row-table");
+        break;
+      case "array-row-table":
+        yield M(r, "array-row-table");
+        break;
+      case "columnar-table":
+        yield M(r, "columnar-table");
+        break;
+      case "arrow-table":
+        yield M(r, "arrow-table");
+        break;
+      default:
+        throw new Error(e);
+    }
+}
+const X = 100;
+class st {
+  schema;
+  options;
+  shape;
+  length = 0;
+  rows = null;
+  cursor = 0;
+  _headers = [];
+  constructor(e, r) {
+    if (this.options = r, this.schema = e, !Array.isArray(e)) {
+      this._headers = [];
+      for (const s in e)
+        this._headers[e[s].index] = e[s].name;
+    }
+  }
+  rowCount() {
+    return this.length;
+  }
+  addArrayRow(e, r) {
+    Number.isFinite(r) && (this.cursor = r), this.shape = "array-row-table", this.rows = this.rows || new Array(X), this.rows[this.length] = e, this.length++;
+  }
+  addObjectRow(e, r) {
+    Number.isFinite(r) && (this.cursor = r), this.shape = "object-row-table", this.rows = this.rows || new Array(X), this.rows[this.length] = e, this.length++;
+  }
+  getBatch() {
+    let e = this.rows;
+    return e ? (e = e.slice(0, this.length), this.rows = null, {
+      shape: this.shape || "array-row-table",
+      batchType: "data",
+      data: e,
+      length: this.length,
+      schema: this.schema,
+      cursor: this.cursor
+    }) : null;
+  }
+}
+const ee = 100;
+class nt {
+  schema;
+  options;
+  length = 0;
+  objectRows = null;
+  arrayRows = null;
+  cursor = 0;
+  _headers = null;
+  constructor(e, r) {
+    if (this.options = r, this.schema = e, e) {
+      this._headers = [];
+      for (let s = 0; s < e.fields.length; s++)
+        this._headers[s] = e.fields[s].name;
+    }
+  }
+  rowCount() {
+    return this.length;
+  }
+  addArrayRow(e, r) {
+    switch (Number.isFinite(r) && (this.cursor = r), this._headers ||= et(e), this.options.shape) {
+      case "object-row-table":
+        const s = pe(e, this._headers);
+        this.addObjectRow(s, r);
+        break;
+      case "array-row-table":
+        this.arrayRows = this.arrayRows || new Array(ee), this.arrayRows[this.length] = e, this.length++;
+        break;
+    }
+  }
+  addObjectRow(e, r) {
+    switch (Number.isFinite(r) && (this.cursor = r), this._headers ||= tt(e), this.options.shape) {
+      case "array-row-table":
+        const s = ge(e, this._headers);
+        this.addArrayRow(s, r);
+        break;
+      case "object-row-table":
+        this.objectRows = this.objectRows || new Array(ee), this.objectRows[this.length] = e, this.length++;
+        break;
+    }
+  }
+  getBatch() {
+    let e = this.arrayRows || this.objectRows;
+    return e ? (e = e.slice(0, this.length), this.arrayRows = null, this.objectRows = null, {
+      shape: this.options.shape,
+      batchType: "data",
+      data: e,
+      length: this.length,
+      // @ts-expect-error we should infer a schema
+      schema: this.schema,
+      cursor: this.cursor
+    }) : null;
+  }
+}
+const it = 100;
+class we {
+  schema;
+  length = 0;
+  allocated = 0;
+  columns = {};
+  constructor(e, r) {
+    this.schema = e, this._reallocateColumns();
+  }
+  rowCount() {
+    return this.length;
+  }
+  addArrayRow(e) {
+    this._reallocateColumns();
+    let r = 0;
+    for (const s in this.columns)
+      this.columns[s][this.length] = e[r++];
+    this.length++;
+  }
+  addObjectRow(e) {
+    this._reallocateColumns();
+    for (const r in e)
+      this.columns[r][this.length] = e[r];
+    this.length++;
+  }
+  getBatch() {
+    return this._pruneColumns(), {
+      shape: "columnar-table",
+      batchType: "data",
+      data: this.columns,
+      schema: this.schema,
+      length: this.length
+    };
+  }
+  // HELPERS
+  _reallocateColumns() {
+    if (!(this.length < this.allocated)) {
+      this.allocated = this.allocated > 0 ? this.allocated *= 2 : it, this.columns = {};
+      for (const e of this.schema.fields) {
+        const r = ce(e.type, e.nullable), s = this.columns[e.name];
+        if (!s)
+          this.columns[e.name] = new r(this.allocated);
+        else if (Array.isArray(s))
+          s.length = this.allocated;
+        else if (De(s)) {
+          const n = new r(this.allocated);
+          n.set(s), this.columns[e.name] = n;
+        } else
+          throw new Error("Invalid column type");
+      }
+    }
+  }
+  _pruneColumns() {
+    for (const [e, r] of Object.entries(this.columns))
+      this.columns[e] = r.slice(0, this.length);
+  }
+}
+class at extends we {
+  arrowSchema;
+  constructor(e, r) {
+    super(e, r), this.arrowSchema = null;
+  }
+  getBatch() {
+    const e = super.getBatch();
+    if (e) {
+      this.arrowSchema = this.arrowSchema || ot(e.schema);
+      const r = lt(this.arrowSchema, e.data), s = new J(this.arrowSchema, Fe({
+        type: new he(this.arrowSchema.fields),
+        children: r.map(({ data: n }) => n[0])
+      }));
+      return {
+        shape: "arrow-table",
+        batchType: "data",
+        data: new ue([s]),
+        length: e.length
+      };
+    }
+    return null;
+  }
+}
+function ot(t) {
+  const e = [];
+  for (const r in t) {
+    const s = t[r];
+    if (s.type === Float32Array) {
+      const n = /* @__PURE__ */ new Map(), a = new je(s.name, new xe(), s.nullable, n);
+      e.push(a);
+    }
+  }
+  if (e.length === 0)
+    throw new Error("No arrow convertible fields");
+  return new Ie(e);
+}
+function lt(t, e) {
+  const r = [];
+  for (const s of t.fields) {
+    const n = e[s.name];
+    if (n instanceof Float32Array) {
+      const a = Ne(n);
+      r.push(a);
+    }
+  }
+  if (t.fields.length !== r.length)
+    throw new Error("Some columns not arrow convertible");
+  return r;
+}
+const ct = {
+  shape: void 0,
+  batchSize: "auto",
+  batchDebounceMs: 0,
+  limit: 0,
+  _limitMB: 0
+};
+class ht {
+  schema;
+  options;
+  aggregator = null;
+  batchCount = 0;
+  bytesUsed = 0;
+  isChunkComplete = !1;
+  lastBatchEmittedMs = Date.now();
+  totalLength = 0;
+  totalBytes = 0;
+  rowBytes = 0;
+  static ArrowBatch;
+  constructor(e, r) {
+    this.schema = e, this.options = { ...ct, ...r };
+  }
+  limitReached() {
+    return !!(this.options?.limit && this.totalLength >= this.options.limit || this.options?._limitMB && this.totalBytes / 1e6 >= this.options._limitMB);
+  }
+  /** @deprecated Use addArrayRow or addObjectRow */
+  addRow(e) {
+    this.limitReached() || (this.totalLength++, this.rowBytes = this.rowBytes || this._estimateRowMB(e), this.totalBytes += this.rowBytes, Array.isArray(e) ? this.addArrayRow(e) : this.addObjectRow(e));
+  }
+  /** Add one row to the batch */
+  addArrayRow(e) {
+    if (!this.aggregator) {
+      const r = this._getTableBatchType();
+      this.aggregator = new r(this.schema, this.options);
+    }
+    this.aggregator.addArrayRow(e);
+  }
+  /** Add one row to the batch */
+  addObjectRow(e) {
+    if (!this.aggregator) {
+      const r = this._getTableBatchType();
+      this.aggregator = new r(this.schema, this.options);
+    }
+    this.aggregator.addObjectRow(e);
+  }
+  /** Mark an incoming raw memory chunk has completed */
+  chunkComplete(e) {
+    e instanceof ArrayBuffer && (this.bytesUsed += e.byteLength), typeof e == "string" && (this.bytesUsed += e.length), this.isChunkComplete = !0;
+  }
+  getFullBatch(e) {
+    return this._isFull() ? this._getBatch(e) : null;
+  }
+  getFinalBatch(e) {
+    return this._getBatch(e);
+  }
+  // INTERNAL
+  _estimateRowMB(e) {
+    return Array.isArray(e) ? e.length * 8 : Object.keys(e).length * 8;
+  }
+  _isFull() {
+    if (!this.aggregator || this.aggregator.rowCount() === 0)
+      return !1;
+    if (this.options.batchSize === "auto") {
+      if (!this.isChunkComplete)
+        return !1;
+    } else if (this.options.batchSize > this.aggregator.rowCount())
+      return !1;
+    return this.options.batchDebounceMs > Date.now() - this.lastBatchEmittedMs ? !1 : (this.isChunkComplete = !1, this.lastBatchEmittedMs = Date.now(), !0);
+  }
+  /**
+   * bytesUsed can be set via chunkComplete or via getBatch*
+   */
+  _getBatch(e) {
+    if (!this.aggregator)
+      return null;
+    e?.bytesUsed && (this.bytesUsed = e.bytesUsed);
+    const r = this.aggregator.getBatch();
+    return r.count = this.batchCount, r.bytesUsed = this.bytesUsed, Object.assign(r, e), this.batchCount++, this.aggregator = null, r;
+  }
+  _getTableBatchType() {
+    switch (this.options.shape) {
+      case "array-row-table":
+      case "object-row-table":
+        return nt;
+      case "columnar-table":
+        return we;
+      case "arrow-table":
+        return at;
+      default:
+        return st;
+    }
+  }
+}
+class te extends Array {
+  enqueue(e) {
+    return this.push(e);
+  }
+  dequeue() {
+    return this.shift();
+  }
+}
+class ut {
+  _values;
+  _settlers;
+  _closed;
+  constructor() {
+    this._values = new te(), this._settlers = new te(), this._closed = !1;
+  }
+  close() {
+    for (; this._settlers.length > 0; )
+      this._settlers.dequeue().resolve({ done: !0 });
+    this._closed = !0;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  enqueue(e) {
+    if (this._closed)
+      throw new Error("Closed");
+    if (this._settlers.length > 0) {
+      if (this._values.length > 0)
+        throw new Error("Illegal internal state");
+      const r = this._settlers.dequeue();
+      e instanceof Error ? r.reject(e) : r.resolve({ value: e });
+    } else
+      this._values.enqueue(e);
+  }
+  /**
+   * @returns a Promise for an IteratorResult
+   */
+  next() {
+    if (this._values.length > 0) {
+      const e = this._values.dequeue();
+      return e instanceof Error ? Promise.reject(e) : Promise.resolve({ value: e });
+    }
+    if (this._closed) {
+      if (this._settlers.length > 0)
+        throw new Error("Illegal internal state");
+      return Promise.resolve({ done: !0 });
+    }
+    return new Promise((e, r) => {
+      this._settlers.enqueue({ resolve: e, reject: r });
+    });
+  }
+}
+const re = "\uFEFF", F = {
+  RECORD_SEP: "",
+  UNIT_SEP: "",
+  BYTE_ORDER_MARK: re,
+  BAD_DELIMITERS: ["\r", `
+`, '"', re],
+  WORKERS_SUPPORTED: !1,
+  // !IS_WORKER && !!globalThis.Worker
+  NODE_STREAM_INPUT: 1,
+  // Configurable chunk sizes for local and remote files, respectively
+  LocalChunkSize: 1024 * 1024 * 10,
+  // 10 M,
+  RemoteChunkSize: 1024 * 1024 * 5,
+  // 5 M,
+  DefaultDelimiter: ","
+  // Used if not specified and detection fail,
+};
+function ft(t, e = {}, r = dt) {
+  return new r(e).stream(t);
+}
+let ye = class {
+  _handle;
+  _config;
+  _finished = !1;
+  _completed = !1;
+  _input = null;
+  _baseIndex = 0;
+  _partialLine = "";
+  _rowCount = 0;
+  _start = 0;
+  isFirstChunk = !0;
+  _completeResults = {
+    data: [],
+    errors: [],
+    meta: {}
+  };
+  constructor(e) {
+    const r = { ...e };
+    r.dynamicTypingFunction && (r.dynamicTyping = {}), r.chunkSize = parseInt(r.chunkSize), !e.step && !e.chunk && (r.chunkSize = null), this._handle = new be(r), this._handle.streamer = this, this._config = r;
+  }
+  // eslint-disable-next-line complexity, max-statements
+  parseChunk(e, r) {
+    if (this.isFirstChunk && j(this._config.beforeFirstChunk)) {
+      const h = this._config.beforeFirstChunk(e);
+      h !== void 0 && (e = h);
+    }
+    this.isFirstChunk = !1;
+    const s = this._partialLine + e;
+    this._partialLine = "";
+    let n = this._handle.parse(s, this._baseIndex, !this._finished);
+    if (this._handle.paused() || this._handle.aborted())
+      return;
+    const a = n.meta.cursor;
+    this._finished || (this._partialLine = s.substring(a - this._baseIndex), this._baseIndex = a), n && n.data && (this._rowCount += n.data.length);
+    const c = this._finished || this._config.preview && this._rowCount >= this._config.preview;
+    if (j(this._config.chunk) && !r) {
+      if (this._config.chunk(n, this._handle), this._handle.paused() || this._handle.aborted())
+        return;
+      n = void 0, this._completeResults = void 0;
+    }
+    return !this._config.step && !this._config.chunk && (this._completeResults.data = this._completeResults.data.concat(n.data), this._completeResults.errors = this._completeResults.errors.concat(n.errors), this._completeResults.meta = n.meta), !this._completed && c && j(this._config.complete) && (!n || !n.meta.aborted) && (this._config.complete(this._completeResults, this._input), this._completed = !0), n;
+  }
+  _sendError(e) {
+    j(this._config.error) && this._config.error(e);
+  }
+};
+class dt extends ye {
+  remaining;
+  constructor(e = {}) {
+    super(e);
+  }
+  stream(e) {
+    return this.remaining = e, this._nextChunk();
+  }
+  _nextChunk() {
+    if (this._finished)
+      return;
+    const e = this._config.chunkSize, r = e ? this.remaining.substr(0, e) : this.remaining;
+    return this.remaining = e ? this.remaining.substr(e) : "", this._finished = !this.remaining, this.parseChunk(r);
+  }
+}
+const mt = /^\s*-?(\d*\.?\d+|\d+\.?\d*)(e[-+]?\d+)?\s*$/i, pt = /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/;
+class be {
+  _config;
+  /** Number of times step was called (number of rows parsed) */
+  _stepCounter = 0;
+  /** Number of rows that have been parsed so far */
+  _rowCounter = 0;
+  /** The input being parsed */
+  _input;
+  /** The core parser being used */
+  _parser;
+  /** Whether we are paused or not */
+  _paused = !1;
+  /** Whether the parser has aborted or not */
+  _aborted = !1;
+  /** Temporary state between delimiter detection and processing results */
+  _delimiterError = !1;
+  /** Fields are from the header row of the input, if there is one */
+  _fields = [];
+  /** The last results returned from the parser */
+  _results = {
+    data: [],
+    errors: [],
+    meta: {}
+  };
+  constructor(e) {
+    if (j(e.step)) {
+      const r = e.step;
+      e.step = (s) => {
+        if (this._results = s, this.needsHeaderRow())
+          this.processResults();
+        else {
+          if (this.processResults(), !this._results.data || this._results.data.length === 0)
+            return;
+          this._stepCounter += s.data.length, e.preview && this._stepCounter > e.preview ? this._parser.abort() : r(this._results, this);
+        }
+      };
+    }
+    this._config = e;
+  }
+  /**
+   * Parses input. Most users won't need, and shouldn't mess with, the baseIndex
+   * and ignoreLastRow parameters. They are used by streamers (wrapper functions)
+   * when an input comes in multiple chunks, like from a file.
+   */
+  parse(e, r, s) {
+    const n = this._config.quoteChar || '"';
+    if (this._config.newline || (this._config.newline = gt(e, n)), this._delimiterError = !1, this._config.delimiter)
+      j(this._config.delimiter) && (this._config.delimiter = this._config.delimiter(e), this._results.meta.delimiter = this._config.delimiter);
+    else {
+      const c = this.guessDelimiter(e, this._config.newline, this._config.skipEmptyLines, this._config.comments, this._config.delimitersToGuess);
+      c.successful ? this._config.delimiter = c.bestDelimiter : (this._delimiterError = !0, this._config.delimiter = F.DefaultDelimiter), this._results.meta.delimiter = this._config.delimiter;
+    }
+    const a = _e(this._config);
+    return this._config.preview && this._config.header && a.preview++, this._input = e, this._parser = new W(a), this._results = this._parser.parse(this._input, r, s), this.processResults(), this._paused ? { meta: { paused: !0 } } : this._results || { meta: { paused: !1 } };
+  }
+  paused() {
+    return this._paused;
+  }
+  pause() {
+    this._paused = !0, this._parser.abort(), this._input = this._input.substr(this._parser.getCharIndex());
+  }
+  resume() {
+    this._paused = !1, this.streamer.parseChunk(this._input, !0);
+  }
+  aborted() {
+    return this._aborted;
+  }
+  abort() {
+    this._aborted = !0, this._parser.abort(), this._results.meta.aborted = !0, j(this._config.complete) && this._config.complete(this._results), this._input = "";
+  }
+  testEmptyLine(e) {
+    return this._config.skipEmptyLines === "greedy" ? e.join("").trim() === "" : e.length === 1 && e[0].length === 0;
+  }
+  processResults() {
+    if (this._results && this._delimiterError && (this.addError("Delimiter", "UndetectableDelimiter", `Unable to auto-detect delimiting character; defaulted to '${F.DefaultDelimiter}'`), this._delimiterError = !1), this._config.skipEmptyLines)
+      for (let e = 0; e < this._results.data.length; e++)
+        this.testEmptyLine(this._results.data[e]) && this._results.data.splice(e--, 1);
+    return this.needsHeaderRow() && this.fillHeaderFields(), this.applyHeaderAndDynamicTypingAndTransformation();
+  }
+  needsHeaderRow() {
+    return this._config.header && this._fields.length === 0;
+  }
+  fillHeaderFields() {
+    if (!this._results)
+      return;
+    const e = (r) => {
+      j(this._config.transformHeader) && (r = this._config.transformHeader(r)), this._fields.push(r);
+    };
+    if (Array.isArray(this._results.data[0])) {
+      for (let r = 0; this.needsHeaderRow() && r < this._results.data.length; r++)
+        this._results.data[r].forEach(e);
+      this._results.data.splice(0, 1);
+    } else
+      this._results.data.forEach(e);
+  }
+  shouldApplyDynamicTyping(e) {
+    return this._config.dynamicTypingFunction && this._config.dynamicTyping?.[e] === void 0 && (this._config.dynamicTyping[e] = this._config.dynamicTypingFunction(e)), (this._config.dynamicTyping?.[e] || this._config.dynamicTyping) === !0;
+  }
+  parseDynamic(e, r) {
+    return this.shouldApplyDynamicTyping(e) ? r === "true" || r === "TRUE" ? !0 : r === "false" || r === "FALSE" ? !1 : mt.test(r) ? parseFloat(r) : pt.test(r) ? new Date(r) : r === "" ? null : r : r;
+  }
+  applyHeaderAndDynamicTypingAndTransformation() {
+    if (!this._results || !this._results.data || !this._config.header && !this._config.dynamicTyping && !this._config.transform)
+      return this._results;
+    let e = 1;
+    return !this._results.data[0] || Array.isArray(this._results.data[0]) ? (this._results.data = this._results.data.map(this.processRow.bind(this)), e = this._results.data.length) : this._results.data = this.processRow(this._results.data, 0), this._config.header && this._results.meta && (this._results.meta.fields = this._fields), this._rowCounter += e, this._results;
+  }
+  processRow(e, r) {
+    const s = this._config.header ? {} : [];
+    let n;
+    for (n = 0; n < e.length; n++) {
+      let a = n, c = e[n];
+      this._config.header && (a = n >= this._fields.length ? "__parsed_extra" : this._fields[n]), this._config.transform && (c = this._config.transform(c, a)), c = this.parseDynamic(a, c), a === "__parsed_extra" ? (s[a] = s[a] || [], s[a].push(c)) : s[a] = c;
+    }
+    return this._config.header && (n > this._fields.length ? this.addError("FieldMismatch", "TooManyFields", `Too many fields: expected ${this._fields.length} fields but parsed ${n}`, this._rowCounter + r) : n < this._fields.length && this.addError("FieldMismatch", "TooFewFields", `Too few fields: expected ${this._fields.length} fields but parsed ${n}`, this._rowCounter + r)), s;
+  }
+  // eslint-disable-next-line complexity, max-statements
+  guessDelimiter(e, r, s, n, a) {
+    let c, h, f;
+    a = a || [",", "	", "|", ";", F.RECORD_SEP, F.UNIT_SEP];
+    for (let o = 0; o < a.length; o++) {
+      const u = a[o];
+      let i = 0, d = 0, g = 0;
+      f = void 0;
+      const w = new W({
+        comments: n,
+        delimiter: u,
+        newline: r,
+        preview: 10
+      }).parse(e);
+      for (let l = 0; l < w.data.length; l++) {
+        if (s && this.testEmptyLine(w.data[l])) {
+          g++;
+          continue;
+        }
+        const m = w.data[l].length;
+        if (i += m, typeof f > "u") {
+          f = 0;
+          continue;
+        } else m > 1 && (d += Math.abs(m - f), f = m);
+      }
+      w.data.length > 0 && (i /= w.data.length - g), (typeof h > "u" || d > h) && i > 1.99 && (h = d, c = u);
+    }
+    return this._config.delimiter = c, {
+      successful: !!c,
+      bestDelimiter: c
+    };
+  }
+  addError(e, r, s, n) {
+    this._results.errors.push({
+      type: e,
+      code: r,
+      message: s,
+      row: n
+    });
+  }
+}
+function gt(t, e) {
+  t = t.substr(0, 1024 * 1024);
+  const r = new RegExp(`${q(e)}([^]*?)${q(e)}`, "gm");
+  t = t.replace(r, "");
+  const s = t.split("\r"), n = t.split(`
+`), a = n.length > 1 && n[0].length < s[0].length;
+  if (s.length === 1 || a)
+    return `
+`;
+  let c = 0;
+  for (let h = 0; h < s.length; h++)
+    s[h][0] === `
+` && c++;
+  return c >= s.length / 2 ? `\r
+` : "\r";
+}
+function q(t) {
+  return t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function W(t = {}) {
+  let e = t.delimiter, r = t.newline, s = t.comments;
+  const n = t.step, a = t.preview, c = t.fastMode;
+  let h;
+  t.quoteChar === void 0 ? h = '"' : h = t.quoteChar;
+  let f = h;
+  if (t.escapeChar !== void 0 && (f = t.escapeChar), (typeof e != "string" || F.BAD_DELIMITERS.indexOf(e) > -1) && (e = ","), s === e)
+    throw new Error("Comment character same as delimiter");
+  s === !0 ? s = "#" : (typeof s != "string" || F.BAD_DELIMITERS.indexOf(s) > -1) && (s = !1), r !== `
+` && r !== "\r" && r !== `\r
+` && (r = `
+`);
+  let o = 0, u = !1;
+  this.parse = function(i, d, g) {
+    if (typeof i != "string")
+      throw new Error("Input must be a string");
+    const w = i.length, l = e.length, m = r.length, C = s.length, T = j(n);
+    o = 0;
+    let y = [], v = [], p = [], k = 0;
+    if (!i)
+      return S();
+    if (c || c !== !1 && i.indexOf(h) === -1) {
+      const R = i.split(r);
+      for (let D = 0; D < R.length; D++) {
+        const O = R[D];
+        if (o += O.length, D !== R.length - 1)
+          o += r.length;
+        else if (g)
+          return S();
+        if (!(s && O.substr(0, C) === s)) {
+          if (T) {
+            if (y = [], x(O.split(e)), I(), u)
+              return S();
+          } else
+            x(O.split(e));
+          if (a && D >= a)
+            return y = y.slice(0, a), S(!0);
+        }
+      }
+      return S();
+    }
+    let A = i.indexOf(e, o), _ = i.indexOf(r, o);
+    const B = new RegExp(q(f) + q(h), "g");
+    let b;
+    for (; ; ) {
+      if (i[o] === h) {
+        for (b = o, o++; ; ) {
+          if (b = i.indexOf(h, b + 1), b === -1)
+            return g || v.push({
+              type: "Quotes",
+              code: "MissingQuotes",
+              message: "Quoted field unterminated",
+              row: y.length,
+              // row has yet to be inserted
+              index: o
+            }), H();
+          if (b === w - 1) {
+            const Ee = i.substring(o, b).replace(B, h);
+            return H(Ee);
+          }
+          if (h === f && i[b + 1] === f) {
+            b++;
+            continue;
+          }
+          if (h !== f && b !== 0 && i[b - 1] === f)
+            continue;
+          const R = _ === -1 ? A : Math.min(A, _), D = K(R);
+          if (i[b + 1 + D] === e) {
+            if (p.push(i.substring(o, b).replace(B, h)), o = b + 1 + D + l, A = i.indexOf(e, o), _ = i.indexOf(r, o), T && (I(), u))
+              return S();
+            if (a && y.length >= a)
+              return S(!0);
+            break;
+          }
+          const O = K(_);
+          if (i.substr(b + 1 + O, m) === r) {
+            if (p.push(i.substring(o, b).replace(B, h)), Y(b + 1 + O + m), A = i.indexOf(e, o), T && (I(), u))
+              return S();
+            if (a && y.length >= a)
+              return S(!0);
+            break;
+          }
+          v.push({
+            type: "Quotes",
+            code: "InvalidQuotes",
+            message: "Trailing quote on quoted field is malformed",
+            row: y.length,
+            // row has yet to be inserted
+            index: o
+          }), b++;
+        }
+        if (T && (I(), u))
+          return S();
+        if (a && y.length >= a)
+          return S(!0);
+        continue;
+      }
+      if (s && p.length === 0 && i.substr(o, C) === s) {
+        if (_ === -1)
+          return S();
+        o = _ + m, _ = i.indexOf(r, o), A = i.indexOf(e, o);
+        continue;
+      }
+      if (A !== -1 && (A < _ || _ === -1)) {
+        p.push(i.substring(o, A)), o = A + l, A = i.indexOf(e, o);
+        continue;
+      }
+      if (_ !== -1) {
+        if (p.push(i.substring(o, _)), Y(_ + m), T && (I(), u))
+          return S();
+        if (a && y.length >= a)
+          return S(!0);
+        continue;
+      }
+      break;
+    }
+    return H();
+    function x(R) {
+      y.push(R), k = o;
+    }
+    function K(R) {
+      let D = 0;
+      if (R !== -1) {
+        const O = i.substring(b + 1, R);
+        O && O.trim() === "" && (D = O.length);
+      }
+      return D;
+    }
+    function H(R) {
+      return g || (typeof R > "u" && (R = i.substr(o)), p.push(R), o = w, x(p), T && I()), S();
+    }
+    function Y(R) {
+      o = R, x(p), p = [], _ = i.indexOf(r, o);
+    }
+    function S(R, D) {
+      return {
+        data: D || !1 ? y[0] : y,
+        errors: v,
+        meta: {
+          delimiter: e,
+          linebreak: r,
+          aborted: u,
+          truncated: !!R,
+          cursor: k + (d || 0)
+        }
+      };
+    }
+    function I() {
+      n(S(void 0, !0)), y = [], v = [];
+    }
+  }, this.abort = function() {
+    u = !0;
+  }, this.getCharIndex = function() {
+    return o;
+  };
+}
+function _e(t) {
+  if (typeof t != "object" || t === null)
+    return t;
+  const e = Array.isArray(t) ? [] : {};
+  for (const r in t)
+    e[r] = _e(t[r]);
+  return e;
+}
+function j(t) {
+  return typeof t == "function";
+}
+function wt(t, e = {}) {
+  let r = !1, s = !0, n = ",", a = `\r
+`, c = '"', h = c + c, f = !1, o = null;
+  i();
+  const u = new RegExp(yt(c), "g");
+  if (typeof t == "string" && (t = JSON.parse(t)), Array.isArray(t)) {
+    if (!t.length || Array.isArray(t[0]))
+      return d(null, t, f);
+    if (typeof t[0] == "object")
+      return d(o || Object.keys(t[0]), t, f);
+  } else if (typeof t == "object")
+    return typeof t.data == "string" && (t.data = JSON.parse(t.data)), Array.isArray(t.data) && (t.fields || (t.fields = t.meta && t.meta.fields), t.fields || (t.fields = Array.isArray(t.data[0]) ? t.fields : Object.keys(t.data[0])), !Array.isArray(t.data[0]) && typeof t.data[0] != "object" && (t.data = [t.data])), d(t.fields || [], t.data || [], f);
+  throw new Error("Unable to serialize unrecognized input");
+  function i() {
+    if (typeof e == "object") {
+      if (typeof e.delimiter == "string" && !F.BAD_DELIMITERS.filter(function(l) {
+        return e.delimiter?.indexOf(l) !== -1;
+      }).length && (n = e.delimiter), (typeof e.quotes == "boolean" || Array.isArray(e.quotes)) && (r = e.quotes), (typeof e.skipEmptyLines == "boolean" || e.skipEmptyLines === "greedy") && (f = e.skipEmptyLines), typeof e.newline == "string" && (a = e.newline), typeof e.quoteChar == "string" && (c = e.quoteChar), typeof e.header == "boolean" && (s = e.header), Array.isArray(e.columns)) {
+        if (e.columns.length === 0)
+          throw new Error("Option columns is empty");
+        o = e.columns;
+      }
+      e.escapeChar !== void 0 && (h = e.escapeChar + c);
+    }
+  }
+  function d(l, m, C) {
+    let T = "";
+    typeof l == "string" && (l = JSON.parse(l)), typeof m == "string" && (m = JSON.parse(m));
+    const y = Array.isArray(l) && l.length > 0, v = !Array.isArray(m[0]);
+    if (y && s) {
+      for (let p = 0; p < l.length; p++)
+        p > 0 && (T += n), T += g(l[p], p);
+      m.length > 0 && (T += a);
+    }
+    for (let p = 0; p < m.length; p++) {
+      const k = y ? l.length : m[p].length;
+      let A = !1;
+      const _ = y ? Object.keys(m[p]).length === 0 : m[p].length === 0;
+      if (C && !y && (A = C === "greedy" ? m[p].join("").trim() === "" : m[p].length === 1 && m[p][0].length === 0), C === "greedy" && y) {
+        const B = [];
+        for (let b = 0; b < k; b++) {
+          const x = v ? l[b] : b;
+          B.push(m[p][x]);
+        }
+        A = B.join("").trim() === "";
+      }
+      if (!A) {
+        for (let B = 0; B < k; B++) {
+          B > 0 && !_ && (T += n);
+          const b = y && v ? l[B] : B;
+          T += g(m[p][b], B);
+        }
+        p < m.length - 1 && (!C || k > 0 && !_) && (T += a);
+      }
+    }
+    return T;
+  }
+  function g(l, m) {
+    return typeof l > "u" || l === null ? "" : l.constructor === Date ? JSON.stringify(l).slice(1, 25) : (l = l.toString().replace(u, h), typeof r == "boolean" && r || Array.isArray(r) && r[m] || w(l, F.BAD_DELIMITERS) || l.indexOf(n) > -1 || l.charAt(0) === " " || l.charAt(l.length - 1) === " " ? c + l + c : l);
+  }
+  function w(l, m) {
+    for (let C = 0; C < m.length; C++)
+      if (l.indexOf(m[C]) > -1)
+        return !0;
+    return !1;
+  }
+}
+function yt(t) {
+  return t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const $ = {
+  ...F,
+  parse: ft,
+  unparse: wt,
+  ChunkStreamer: ye,
+  // Exposed for testing and development only
+  Parser: W,
+  ParserHandle: be
+}, { ChunkStreamer: bt } = $;
+class _t extends bt {
+  textDecoder = new TextDecoder(this._config.encoding);
+  constructor(e = {}) {
+    super(e);
+  }
+  // Implement ChunkStreamer base class methods
+  // this.pause = function() {
+  //   ChunkStreamer.prototype.pause.apply(this, arguments);
+  // };
+  // this.resume = function() {
+  //   ChunkStreamer.prototype.resume.apply(this, arguments);
+  //   this._input.resume();
+  // };
+  async stream(e) {
+    this._input = e;
+    try {
+      for await (const r of e)
+        this.parseChunk(this.getStringChunk(r));
+      this._finished = !0, this.parseChunk("");
+    } catch (r) {
+      this._sendError(r);
+    }
+  }
+  _nextChunk() {
+  }
+  // HELPER METHODS
+  getStringChunk(e) {
+    return typeof e == "string" ? e : this.textDecoder.decode(e, { stream: !0 });
+  }
+}
+const Ce = {
+  id: "csv",
+  module: "csv",
+  name: "CSV",
+  extensions: ["csv", "tsv", "dsv"],
+  mimeTypes: ["text/csv", "text/tab-separated-values", "text/dsv"],
+  category: "table"
+}, Ct = "4.4.3", Z = "object-row-table", U = {
+  ...Ce,
+  dataType: null,
+  batchType: null,
+  version: Ct,
+  parse: async (t, e) => se(new TextDecoder().decode(t), e),
+  parseText: (t, e) => se(t, e),
+  parseInBatches: At,
+  // @ts-ignore
+  // testText: null,
+  options: {
+    csv: {
+      shape: Z,
+      // 'object-row-table'
+      optimizeMemoryUsage: !1,
+      // CSV options
+      header: "auto",
+      columnPrefix: "column",
+      // delimiter: auto
+      // newline: auto
+      quoteChar: '"',
+      escapeChar: '"',
+      dynamicTyping: !0,
+      comments: !1,
+      skipEmptyLines: !0,
+      // transform: null?
+      delimitersToGuess: [",", "	", "|", ";"]
+      // fastMode: auto
+    }
+  }
+};
+async function se(t, e) {
+  const r = { ...U.options.csv, ...e?.csv }, s = Tt(t), a = r.header === "auto" ? Ae(s) : !!r.header, c = {
+    // dynamicTyping: true,
+    ...r,
+    header: a,
+    download: !1,
+    // We handle loading, no need for papaparse to do it for us
+    transformHeader: a ? Te() : void 0,
+    error: (d) => {
+      throw new Error(d);
+    }
+  }, h = $.parse(t, c), f = h.data, o = h.meta.fields || Re(r.columnPrefix, s.length), u = r.shape || Z;
+  let i;
+  switch (u) {
+    case "object-row-table":
+      i = {
+        shape: "object-row-table",
+        data: f.map((d) => Array.isArray(d) ? pe(d, o) : d)
+      };
+      break;
+    case "array-row-table":
+      i = {
+        shape: "array-row-table",
+        data: f.map((d) => Array.isArray(d) ? d : ge(d, o))
+      };
+      break;
+    default:
+      throw new Error(u);
+  }
+  return i.schema = de(i), i;
+}
+function At(t, e) {
+  e = { ...e }, e?.core?.batchSize === "auto" && (e.core.batchSize = 4e3);
+  const r = { ...U.options.csv, ...e?.csv }, s = new ut();
+  let n = !0, a = null, c = null, h = null;
+  const f = {
+    // dynamicTyping: true, // Convert numbers and boolean values in rows from strings,
+    ...r,
+    header: !1,
+    // Unfortunately, header detection is not automatic and does not infer shapes
+    download: !1,
+    // We handle loading, no need for papaparse to do it for us
+    // chunkSize is set to 5MB explicitly (same as Papaparse default) due to a bug where the
+    // streaming parser gets stuck if skipEmptyLines and a step callback are both supplied.
+    // See https://github.com/mholt/PapaParse/issues/465
+    chunkSize: 1024 * 1024 * 5,
+    // skipEmptyLines is set to a boolean value if supplied. Greedy is set to true
+    // skipEmptyLines is handled manually given two bugs where the streaming parser gets stuck if
+    // both of the skipEmptyLines and step callback options are provided:
+    // - true doesn't work unless chunkSize is set: https://github.com/mholt/PapaParse/issues/465
+    // - greedy doesn't work: https://github.com/mholt/PapaParse/issues/825
+    skipEmptyLines: !1,
+    // step is called on every row
+    // eslint-disable-next-line complexity, max-statements
+    step(o) {
+      let u = o.data;
+      if (r.skipEmptyLines && u.flat().join("").trim() === "")
+        return;
+      const i = o.meta.cursor;
+      if (n && !a && (r.header === "auto" ? Ae(u) : !!r.header)) {
+        a = u.map(Te());
+        return;
+      }
+      n && (n = !1, a || (a = Re(r.columnPrefix, u.length)), h = Rt(u, a)), r.optimizeMemoryUsage && (u = JSON.parse(JSON.stringify(u)));
+      const d = e?.shape || r.shape || Z;
+      c = c || new ht(
+        // @ts-expect-error TODO this is not a proper schema
+        h,
+        {
+          shape: d,
+          ...e?.core || {}
+        }
+      );
+      try {
+        c.addRow(u);
+        const g = c && c.getFullBatch({ bytesUsed: i });
+        g && s.enqueue(g);
+      } catch (g) {
+        s.enqueue(g);
+      }
+    },
+    // complete is called when all rows have been read
+    complete(o) {
+      try {
+        const u = o.meta.cursor, i = c && c.getFinalBatch({ bytesUsed: u });
+        i && s.enqueue(i);
+      } catch (u) {
+        s.enqueue(u);
+      }
+      s.close();
+    }
+  };
+  return $.parse(Oe(t), f, _t), s;
+}
+function Ae(t) {
+  return t && t.every((e) => typeof e == "string");
+}
+function Tt(t) {
+  return $.parse(t, {
+    dynamicTyping: !0,
+    preview: 1
+  }).data[0];
+}
+function Te() {
+  const t = /* @__PURE__ */ new Set();
+  return (e) => {
+    let r = e, s = 1;
+    for (; t.has(r); )
+      r = `${e}.${s}`, s++;
+    return t.add(r), r;
+  };
+}
+function Re(t, e = 0) {
+  const r = [];
+  for (let s = 0; s < e; s++)
+    r.push(`${t}${s + 1}`);
+  return r;
+}
+function Rt(t, e) {
+  const r = [];
+  for (let s = 0; s < t.length; s++) {
+    const n = e && e[s] || s, a = t[s];
+    switch (typeof a) {
+      case "number":
+        r.push({ name: String(n), type: "float64", nullable: !0 });
+        break;
+      case "boolean":
+        r.push({ name: String(n), type: "bool", nullable: !0 });
+        break;
+      case "string":
+        r.push({ name: String(n), type: "utf8", nullable: !0 });
+        break;
+      default:
+        ke.warn(`CSV: Unknown column type: ${typeof a}`)(), r.push({ name: String(n), type: "utf8", nullable: !0 });
+    }
+  }
+  return {
+    fields: r,
+    metadata: {
+      "loaders.gl#format": "csv",
+      "loaders.gl#loader": "CSVLoader"
+    }
+  };
+}
+var ne = {}, P = {}, z = 34, N = 10, Q = 13;
+function Se(t) {
+  return new Function("d", "return {" + t.map(function(e, r) {
+    return JSON.stringify(e) + ": d[" + r + '] || ""';
+  }).join(",") + "}");
+}
+function St(t, e) {
+  var r = Se(t);
+  return function(s, n) {
+    return e(r(s), n, t);
+  };
+}
+function ie(t) {
+  var e = /* @__PURE__ */ Object.create(null), r = [];
+  return t.forEach(function(s) {
+    for (var n in s)
+      n in e || r.push(e[n] = n);
+  }), r;
+}
+function E(t, e) {
+  var r = t + "", s = r.length;
+  return s < e ? new Array(e - s + 1).join(0) + r : r;
+}
+function Et(t) {
+  return t < 0 ? "-" + E(-t, 6) : t > 9999 ? "+" + E(t, 6) : E(t, 4);
+}
+function Bt(t) {
+  var e = t.getUTCHours(), r = t.getUTCMinutes(), s = t.getUTCSeconds(), n = t.getUTCMilliseconds();
+  return isNaN(t) ? "Invalid Date" : Et(t.getUTCFullYear()) + "-" + E(t.getUTCMonth() + 1, 2) + "-" + E(t.getUTCDate(), 2) + (n ? "T" + E(e, 2) + ":" + E(r, 2) + ":" + E(s, 2) + "." + E(n, 3) + "Z" : s ? "T" + E(e, 2) + ":" + E(r, 2) + ":" + E(s, 2) + "Z" : r || e ? "T" + E(e, 2) + ":" + E(r, 2) + "Z" : "");
+}
+function Dt(t) {
+  var e = new RegExp('["' + t + `
+\r]`), r = t.charCodeAt(0);
+  function s(i, d) {
+    var g, w, l = n(i, function(m, C) {
+      if (g) return g(m, C - 1);
+      w = m, g = d ? St(m, d) : Se(m);
+    });
+    return l.columns = w || [], l;
+  }
+  function n(i, d) {
+    var g = [], w = i.length, l = 0, m = 0, C, T = w <= 0, y = !1;
+    i.charCodeAt(w - 1) === N && --w, i.charCodeAt(w - 1) === Q && --w;
+    function v() {
+      if (T) return P;
+      if (y) return y = !1, ne;
+      var k, A = l, _;
+      if (i.charCodeAt(A) === z) {
+        for (; l++ < w && i.charCodeAt(l) !== z || i.charCodeAt(++l) === z; ) ;
+        return (k = l) >= w ? T = !0 : (_ = i.charCodeAt(l++)) === N ? y = !0 : _ === Q && (y = !0, i.charCodeAt(l) === N && ++l), i.slice(A + 1, k - 1).replace(/""/g, '"');
+      }
+      for (; l < w; ) {
+        if ((_ = i.charCodeAt(k = l++)) === N) y = !0;
+        else if (_ === Q)
+          y = !0, i.charCodeAt(l) === N && ++l;
+        else if (_ !== r) continue;
+        return i.slice(A, k);
+      }
+      return T = !0, i.slice(A, w);
+    }
+    for (; (C = v()) !== P; ) {
+      for (var p = []; C !== ne && C !== P; ) p.push(C), C = v();
+      d && (p = d(p, m++)) == null || g.push(p);
+    }
+    return g;
+  }
+  function a(i, d) {
+    return i.map(function(g) {
+      return d.map(function(w) {
+        return u(g[w]);
+      }).join(t);
+    });
+  }
+  function c(i, d) {
+    return d == null && (d = ie(i)), [d.map(u).join(t)].concat(a(i, d)).join(`
+`);
+  }
+  function h(i, d) {
+    return d == null && (d = ie(i)), a(i, d).join(`
+`);
+  }
+  function f(i) {
+    return i.map(o).join(`
+`);
+  }
+  function o(i) {
+    return i.map(u).join(t);
+  }
+  function u(i) {
+    return i == null ? "" : i instanceof Date ? Bt(i) : e.test(i += "") ? '"' + i.replace(/"/g, '""') + '"' : i;
+  }
+  return {
+    parse: s,
+    parseRows: n,
+    format: c,
+    formatBody: h,
+    formatRows: f,
+    formatRow: o,
+    formatValue: u
+  };
+}
+var Ot = Dt(","), kt = Ot.formatRows;
+function ae(t, e = { csv: { useDisplayNames: !0 } }) {
+  const r = e.useDisplayNames || e.csv?.useDisplayNames, a = [(t.schema?.fields || []).map((h) => {
+    const f = h.metadata?.displayName;
+    return r && typeof f == "string" ? f : h.name;
+  })];
+  for (const h of Ve(t)) {
+    const f = [];
+    for (let o = 0; o < fe(t); ++o) {
+      const u = h[o];
+      f[o] = vt(u);
+    }
+    a.push(f);
+  }
+  const c = a.map((h) => h.map((f) => f === null ? "" : f));
+  return kt(c);
+}
+const vt = (t) => t == null ? null : t instanceof Date ? t.toISOString() : typeof t == "object" ? JSON.stringify(t) : String(t), Ut = {
+  ...Ce,
+  version: "latest",
+  options: {
+    csv: {
+      useDisplayNames: !1
+    }
+  },
+  text: !0,
+  encode: async (t, e) => new TextEncoder().encode(ae(t, e)).buffer,
+  encodeTextSync: (t, e) => ae(t, e)
+}, Mt = {
+  ...U,
+  dataType: null,
+  batchType: null,
+  parse: async (t, e) => oe(new TextDecoder().decode(t), e),
+  parseText: (t, e) => oe(t, e),
+  parseInBatches: Ft
+};
+async function oe(t, e) {
+  const r = await U.parseText(t, e);
+  return L(r, "arrow-table");
+}
+function Ft(t, e) {
+  const r = U.parseInBatches(t, e);
+  return rt(r, "arrow-table");
+}
+export {
+  Mt as CSVArrowLoader,
+  U as CSVLoader,
+  Ut as CSVWriter
+};