@nika-js/onlymap 0.1.0

package/dist/index-Do7hmHwi.js

@@ -0,0 +1,1457 @@
+var Oe = Object.defineProperty;
+var ke = (r, e, t) => e in r ? Oe(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var l = (r, e, t) => ke(r, typeof e != "symbol" ? e + "" : e, t);
+import { g as ve, a as ce, b as he, i as Fe, t as je, l as xe } from "./index-CU-iOTdr.js";
+import { ai as Ie, h as ue, au as X, a2 as W, af as fe, Y as Ne, F as Le, aR as Ue, S as Me, bP as qe } from "./recordbatch-HRu0SMKp.js";
+import { g as $, a as de, b as Ve, c as $e, d as Pe, e as He, m as ze } from "./table-accessors-DBjWgN0C.js";
+import { c as Qe } from "./convert-arrow-schema-CvZ3cT5m.js";
+function me(r) {
+  switch (r.shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return We(r.data);
+    case "geojson-table":
+      return Ze(r.features);
+    case "columnar-table":
+      return Je(r.data);
+    case "arrow-table":
+    default:
+      throw new Error("Deduce schema");
+  }
+}
+function Je(r) {
+  const e = [];
+  for (const [t, s] of Object.entries(r)) {
+    const i = Ye(s, t);
+    e.push(i);
+  }
+  return { fields: e, metadata: {} };
+}
+function We(r) {
+  if (!r.length)
+    throw new Error("deduce from empty table");
+  const e = [], t = r[0];
+  for (const [s, i] of Object.entries(t))
+    e.push(ge(i, s));
+  return { fields: e, metadata: {} };
+}
+function Ze(r) {
+  if (!r.length)
+    throw new Error("deduce from empty table");
+  const e = [], t = r[0].properties || {};
+  for (const [s, i] of Object.entries(t))
+    e.push(ge(i, s));
+  return { fields: e, metadata: {} };
+}
+function Ye(r, e) {
+  if (ArrayBuffer.isView(r)) {
+    const t = ve(r);
+    return {
+      name: e,
+      type: t.type || "null",
+      nullable: t.nullable
+      // metadata: {}
+    };
+  }
+  if (Array.isArray(r) && r.length > 0) {
+    const t = r[0], s = ce(t);
+    return {
+      name: e,
+      type: s,
+      nullable: !0
+      // metadata: {},
+    };
+  }
+  throw new Error("empty table");
+}
+function ge(r, e) {
+  const t = ce(r);
+  return {
+    name: e,
+    type: t,
+    nullable: !0
+    // metadata: {}
+  };
+}
+function Ke(r, e) {
+  const t = he(r.type, r.nullable);
+  return new t(e);
+}
+function* Ge(r, e) {
+  const t = Qe(r.schema), s = $(r), i = de(r), a = s, h = t == null ? void 0 : t.fields.map((o) => Ie(o)), f = new ue(t.fields);
+  let m = 0;
+  for (let o = 0; o < s; o++)
+    for (let d = 0; d < i; ++d) {
+      const n = Ve(r, o, d);
+      if (h[d].append(n), m++, m >= a) {
+        const _ = h.map((c) => c.flush()), p = new X(f, 0, m, 0, void 0, _);
+        yield new W(t, p), m = 0;
+      }
+    }
+  if (m > 0) {
+    const o = h.map((n) => n.flush()), d = new X(f, 0, m, 0, void 0, o);
+    yield new W(t, d), m = 0;
+  }
+  h.map((o) => o.finish());
+}
+function Xe(r, e) {
+  switch (r.shape) {
+    case "arrow-table":
+      return r.data;
+    case "columnar-table":
+    // TODO - optimized implementation is possible
+    // return convertColumnarTableToArrow(table, options);
+    // fall through
+    default:
+      const t = Ge(r);
+      return new fe(t);
+  }
+}
+function U(r, e) {
+  switch (e) {
+    case "object-row-table":
+      return rt(r);
+    case "array-row-table":
+      return tt(r);
+    case "columnar-table":
+      return et(r);
+    case "arrow-table":
+      return st(r);
+    default:
+      throw new Error(e);
+  }
+}
+function et(r) {
+  var a;
+  const e = r.schema || me(r), t = ((a = r.schema) == null ? void 0 : a.fields) || [];
+  if (r.shape === "columnar-table")
+    return { ...r, schema: e };
+  const s = $(r), i = {};
+  for (const h of t) {
+    const f = Ke(h, s);
+    i[h.name] = f;
+    for (let m = 0; m < s; m++)
+      f[m] = $e(r, m, h.name);
+  }
+  return {
+    shape: "columnar-table",
+    schema: e,
+    data: i
+  };
+}
+function tt(r) {
+  if (r.shape === "array-row-table")
+    return r;
+  const e = $(r), t = new Array(e);
+  for (let s = 0; s < e; s++)
+    t[s] = Pe(r, s);
+  return {
+    shape: "array-row-table",
+    schema: r.schema,
+    data: t
+  };
+}
+function rt(r) {
+  if (r.shape === "object-row-table")
+    return r;
+  const e = $(r), t = new Array(e);
+  for (let s = 0; s < e; s++)
+    t[s] = He(r, s);
+  return {
+    shape: "object-row-table",
+    schema: r.schema,
+    data: t
+  };
+}
+function st(r) {
+  const e = Xe(r);
+  return {
+    shape: "arrow-table",
+    schema: r.schema,
+    data: e
+  };
+}
+function pe(r, e) {
+  if (!r)
+    throw new Error("null row");
+  const t = {};
+  if (e)
+    for (let s = 0; s < e.length; s++)
+      t[e[s]] = r[s];
+  else
+    for (let s = 0; s < r.length; s++) {
+      const i = `column-${s}`;
+      t[i] = r[s];
+    }
+  return t;
+}
+function we(r, e) {
+  if (!r)
+    throw new Error("null row");
+  if (e) {
+    const t = new Array(e.length);
+    for (let s = 0; s < e.length; s++)
+      t[s] = r[e[s]];
+    return t;
+  }
+  return Object.values(r);
+}
+function nt(r) {
+  const e = [];
+  for (let t = 0; t < r.length; t++) {
+    const s = `column-${t}`;
+    e.push(s);
+  }
+  return e;
+}
+function it(r) {
+  return Object.keys(r);
+}
+function q(r, e) {
+  switch (e) {
+    case "object-row-table":
+      return { ...r, ...U(r, "object-row-table") };
+    case "array-row-table":
+      return { ...r, ...U(r, "array-row-table") };
+    case "columnar-table":
+      return { ...r, ...U(r, "columnar-table") };
+    case "arrow-table":
+      return { ...r, ...U(r, "arrow-table") };
+    default:
+      throw new Error(e);
+  }
+}
+async function* at(r, e) {
+  for await (const t of r)
+    switch (e) {
+      case "object-row-table":
+        yield q(t, "object-row-table");
+        break;
+      case "array-row-table":
+        yield q(t, "array-row-table");
+        break;
+      case "columnar-table":
+        yield q(t, "columnar-table");
+        break;
+      case "arrow-table":
+        yield q(t, "arrow-table");
+        break;
+      default:
+        throw new Error(e);
+    }
+}
+const ee = 100;
+class ot {
+  constructor(e, t) {
+    l(this, "schema");
+    l(this, "options");
+    l(this, "shape");
+    l(this, "length", 0);
+    l(this, "rows", null);
+    l(this, "cursor", 0);
+    l(this, "_headers", []);
+    if (this.options = t, 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, t) {
+    Number.isFinite(t) && (this.cursor = t), this.shape = "array-row-table", this.rows = this.rows || new Array(ee), this.rows[this.length] = e, this.length++;
+  }
+  addObjectRow(e, t) {
+    Number.isFinite(t) && (this.cursor = t), this.shape = "object-row-table", this.rows = this.rows || new Array(ee), 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 te = 100;
+class lt {
+  constructor(e, t) {
+    l(this, "schema");
+    l(this, "options");
+    l(this, "length", 0);
+    l(this, "objectRows", null);
+    l(this, "arrayRows", null);
+    l(this, "cursor", 0);
+    l(this, "_headers", null);
+    if (this.options = t, 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, t) {
+    switch (Number.isFinite(t) && (this.cursor = t), this._headers || (this._headers = nt(e)), this.options.shape) {
+      case "object-row-table":
+        const s = pe(e, this._headers);
+        this.addObjectRow(s, t);
+        break;
+      case "array-row-table":
+        this.arrayRows = this.arrayRows || new Array(te), this.arrayRows[this.length] = e, this.length++;
+        break;
+    }
+  }
+  addObjectRow(e, t) {
+    switch (Number.isFinite(t) && (this.cursor = t), this._headers || (this._headers = it(e)), this.options.shape) {
+      case "array-row-table":
+        const s = we(e, this._headers);
+        this.addArrayRow(s, t);
+        break;
+      case "object-row-table":
+        this.objectRows = this.objectRows || new Array(te), 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 ct = 100;
+class ye {
+  constructor(e, t) {
+    l(this, "schema");
+    l(this, "length", 0);
+    l(this, "allocated", 0);
+    l(this, "columns", {});
+    this.schema = e, this._reallocateColumns();
+  }
+  rowCount() {
+    return this.length;
+  }
+  addArrayRow(e) {
+    this._reallocateColumns();
+    let t = 0;
+    for (const s in this.columns)
+      this.columns[s][this.length] = e[t++];
+    this.length++;
+  }
+  addObjectRow(e) {
+    this._reallocateColumns();
+    for (const t in e)
+      this.columns[t][this.length] = e[t];
+    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 : ct, this.columns = {};
+      for (const e of this.schema.fields) {
+        const t = he(e.type, e.nullable), s = this.columns[e.name];
+        if (!s)
+          this.columns[e.name] = new t(this.allocated);
+        else if (Array.isArray(s))
+          s.length = this.allocated;
+        else if (Fe(s)) {
+          const i = new t(this.allocated);
+          i.set(s), this.columns[e.name] = i;
+        } else
+          throw new Error("Invalid column type");
+      }
+    }
+  }
+  _pruneColumns() {
+    for (const [e, t] of Object.entries(this.columns))
+      this.columns[e] = t.slice(0, this.length);
+  }
+}
+class ht extends ye {
+  constructor(t, s) {
+    super(t, s);
+    l(this, "arrowSchema");
+    this.arrowSchema = null;
+  }
+  getBatch() {
+    const t = super.getBatch();
+    if (t) {
+      this.arrowSchema = this.arrowSchema || ut(t.schema);
+      const s = ft(this.arrowSchema, t.data), i = new W(this.arrowSchema, Ne({
+        type: new ue(this.arrowSchema.fields),
+        children: s.map(({ data: a }) => a[0])
+      }));
+      return {
+        shape: "arrow-table",
+        batchType: "data",
+        data: new fe([i]),
+        length: t.length
+      };
+    }
+    return null;
+  }
+}
+function ut(r) {
+  const e = [];
+  for (const t in r) {
+    const s = r[t];
+    if (s.type === Float32Array) {
+      const i = /* @__PURE__ */ new Map(), a = new Le(s.name, new Ue(), s.nullable, i);
+      e.push(a);
+    }
+  }
+  if (e.length === 0)
+    throw new Error("No arrow convertible fields");
+  return new Me(e);
+}
+function ft(r, e) {
+  const t = [];
+  for (const s of r.fields) {
+    const i = e[s.name];
+    if (i instanceof Float32Array) {
+      const a = qe(i);
+      t.push(a);
+    }
+  }
+  if (r.fields.length !== t.length)
+    throw new Error("Some columns not arrow convertible");
+  return t;
+}
+const dt = {
+  shape: void 0,
+  batchSize: "auto",
+  batchDebounceMs: 0,
+  limit: 0,
+  _limitMB: 0
+};
+class be {
+  constructor(e, t) {
+    l(this, "schema");
+    l(this, "options");
+    l(this, "aggregator", null);
+    l(this, "batchCount", 0);
+    l(this, "bytesUsed", 0);
+    l(this, "isChunkComplete", !1);
+    l(this, "lastBatchEmittedMs", Date.now());
+    l(this, "totalLength", 0);
+    l(this, "totalBytes", 0);
+    l(this, "rowBytes", 0);
+    this.schema = e, this.options = { ...dt, ...t };
+  }
+  limitReached() {
+    var e, t;
+    return !!((e = this.options) != null && e.limit && this.totalLength >= this.options.limit || (t = this.options) != null && t._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 t = this._getTableBatchType();
+      this.aggregator = new t(this.schema, this.options);
+    }
+    this.aggregator.addArrayRow(e);
+  }
+  /** Add one row to the batch */
+  addObjectRow(e) {
+    if (!this.aggregator) {
+      const t = this._getTableBatchType();
+      this.aggregator = new t(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 != null && e.bytesUsed && (this.bytesUsed = e.bytesUsed);
+    const t = this.aggregator.getBatch();
+    return t.count = this.batchCount, t.bytesUsed = this.bytesUsed, Object.assign(t, e), this.batchCount++, this.aggregator = null, t;
+  }
+  _getTableBatchType() {
+    switch (this.options.shape) {
+      case "array-row-table":
+      case "object-row-table":
+        return lt;
+      case "columnar-table":
+        return ye;
+      case "arrow-table":
+        return ht;
+      default:
+        return ot;
+    }
+  }
+}
+l(be, "ArrowBatch");
+class re extends Array {
+  enqueue(e) {
+    return this.push(e);
+  }
+  dequeue() {
+    return this.shift();
+  }
+}
+class mt {
+  constructor() {
+    l(this, "_values");
+    l(this, "_settlers");
+    l(this, "_closed");
+    this._values = new re(), this._settlers = new re(), 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 t = this._settlers.dequeue();
+      e instanceof Error ? t.reject(e) : t.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, t) => {
+      this._settlers.enqueue({ resolve: e, reject: t });
+    });
+  }
+}
+const se = "\uFEFF", j = {
+  RECORD_SEP: "",
+  UNIT_SEP: "",
+  BYTE_ORDER_MARK: se,
+  BAD_DELIMITERS: ["\r", `
+`, '"', se],
+  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 gt(r, e = {}, t = pt) {
+  return new t(e).stream(r);
+}
+let _e = class {
+  constructor(e) {
+    l(this, "_handle");
+    l(this, "_config");
+    l(this, "_finished", !1);
+    l(this, "_completed", !1);
+    l(this, "_input", null);
+    l(this, "_baseIndex", 0);
+    l(this, "_partialLine", "");
+    l(this, "_rowCount", 0);
+    l(this, "_start", 0);
+    l(this, "isFirstChunk", !0);
+    l(this, "_completeResults", {
+      data: [],
+      errors: [],
+      meta: {}
+    });
+    const t = { ...e };
+    t.dynamicTypingFunction && (t.dynamicTyping = {}), t.chunkSize = parseInt(t.chunkSize), !e.step && !e.chunk && (t.chunkSize = null), this._handle = new Ce(t), this._handle.streamer = this, this._config = t;
+  }
+  // eslint-disable-next-line complexity, max-statements
+  parseChunk(e, t) {
+    if (this.isFirstChunk && x(this._config.beforeFirstChunk)) {
+      const f = this._config.beforeFirstChunk(e);
+      f !== void 0 && (e = f);
+    }
+    this.isFirstChunk = !1;
+    const s = this._partialLine + e;
+    this._partialLine = "";
+    let i = this._handle.parse(s, this._baseIndex, !this._finished);
+    if (this._handle.paused() || this._handle.aborted())
+      return;
+    const a = i.meta.cursor;
+    this._finished || (this._partialLine = s.substring(a - this._baseIndex), this._baseIndex = a), i && i.data && (this._rowCount += i.data.length);
+    const h = this._finished || this._config.preview && this._rowCount >= this._config.preview;
+    if (x(this._config.chunk) && !t) {
+      if (this._config.chunk(i, this._handle), this._handle.paused() || this._handle.aborted())
+        return;
+      i = void 0, this._completeResults = void 0;
+    }
+    return !this._config.step && !this._config.chunk && (this._completeResults.data = this._completeResults.data.concat(i.data), this._completeResults.errors = this._completeResults.errors.concat(i.errors), this._completeResults.meta = i.meta), !this._completed && h && x(this._config.complete) && (!i || !i.meta.aborted) && (this._config.complete(this._completeResults, this._input), this._completed = !0), i;
+  }
+  _sendError(e) {
+    x(this._config.error) && this._config.error(e);
+  }
+};
+class pt extends _e {
+  constructor(t = {}) {
+    super(t);
+    l(this, "remaining");
+  }
+  stream(t) {
+    return this.remaining = t, this._nextChunk();
+  }
+  _nextChunk() {
+    if (this._finished)
+      return;
+    const t = this._config.chunkSize, s = t ? this.remaining.substr(0, t) : this.remaining;
+    return this.remaining = t ? this.remaining.substr(t) : "", this._finished = !this.remaining, this.parseChunk(s);
+  }
+}
+const wt = /^\s*-?(\d*\.?\d+|\d+\.?\d*)(e[-+]?\d+)?\s*$/i, yt = /(\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 Ce {
+  constructor(e) {
+    l(this, "_config");
+    /** Number of times step was called (number of rows parsed) */
+    l(this, "_stepCounter", 0);
+    /** Number of rows that have been parsed so far */
+    l(this, "_rowCounter", 0);
+    /** The input being parsed */
+    l(this, "_input");
+    /** The core parser being used */
+    l(this, "_parser");
+    /** Whether we are paused or not */
+    l(this, "_paused", !1);
+    /** Whether the parser has aborted or not */
+    l(this, "_aborted", !1);
+    /** Temporary state between delimiter detection and processing results */
+    l(this, "_delimiterError", !1);
+    /** Fields are from the header row of the input, if there is one */
+    l(this, "_fields", []);
+    /** The last results returned from the parser */
+    l(this, "_results", {
+      data: [],
+      errors: [],
+      meta: {}
+    });
+    if (x(e.step)) {
+      const t = 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() : t(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, t, s) {
+    const i = this._config.quoteChar || '"';
+    if (this._config.newline || (this._config.newline = bt(e, i)), this._delimiterError = !1, this._config.delimiter)
+      x(this._config.delimiter) && (this._config.delimiter = this._config.delimiter(e), this._results.meta.delimiter = this._config.delimiter);
+    else {
+      const h = this.guessDelimiter(e, this._config.newline, this._config.skipEmptyLines, this._config.comments, this._config.delimitersToGuess);
+      h.successful ? this._config.delimiter = h.bestDelimiter : (this._delimiterError = !0, this._config.delimiter = j.DefaultDelimiter), this._results.meta.delimiter = this._config.delimiter;
+    }
+    const a = Ae(this._config);
+    return this._config.preview && this._config.header && a.preview++, this._input = e, this._parser = new Z(a), this._results = this._parser.parse(this._input, t, 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, x(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 '${j.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 = (t) => {
+      x(this._config.transformHeader) && (t = this._config.transformHeader(t)), this._fields.push(t);
+    };
+    if (Array.isArray(this._results.data[0])) {
+      for (let t = 0; this.needsHeaderRow() && t < this._results.data.length; t++)
+        this._results.data[t].forEach(e);
+      this._results.data.splice(0, 1);
+    } else
+      this._results.data.forEach(e);
+  }
+  shouldApplyDynamicTyping(e) {
+    var t, s;
+    return this._config.dynamicTypingFunction && ((t = this._config.dynamicTyping) == null ? void 0 : t[e]) === void 0 && (this._config.dynamicTyping[e] = this._config.dynamicTypingFunction(e)), (((s = this._config.dynamicTyping) == null ? void 0 : s[e]) || this._config.dynamicTyping) === !0;
+  }
+  parseDynamic(e, t) {
+    return this.shouldApplyDynamicTyping(e) ? t === "true" || t === "TRUE" ? !0 : t === "false" || t === "FALSE" ? !1 : wt.test(t) ? parseFloat(t) : yt.test(t) ? new Date(t) : t === "" ? null : t : t;
+  }
+  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, t) {
+    const s = this._config.header ? {} : [];
+    let i;
+    for (i = 0; i < e.length; i++) {
+      let a = i, h = e[i];
+      this._config.header && (a = i >= this._fields.length ? "__parsed_extra" : this._fields[i]), this._config.transform && (h = this._config.transform(h, a)), h = this.parseDynamic(a, h), a === "__parsed_extra" ? (s[a] = s[a] || [], s[a].push(h)) : s[a] = h;
+    }
+    return this._config.header && (i > this._fields.length ? this.addError("FieldMismatch", "TooManyFields", `Too many fields: expected ${this._fields.length} fields but parsed ${i}`, this._rowCounter + t) : i < this._fields.length && this.addError("FieldMismatch", "TooFewFields", `Too few fields: expected ${this._fields.length} fields but parsed ${i}`, this._rowCounter + t)), s;
+  }
+  // eslint-disable-next-line complexity, max-statements
+  guessDelimiter(e, t, s, i, a) {
+    let h, f, m;
+    a = a || [",", "	", "|", ";", j.RECORD_SEP, j.UNIT_SEP];
+    for (let o = 0; o < a.length; o++) {
+      const d = a[o];
+      let n = 0, u = 0, _ = 0;
+      m = void 0;
+      const p = new Z({
+        comments: i,
+        delimiter: d,
+        newline: t,
+        preview: 10
+      }).parse(e);
+      for (let c = 0; c < p.data.length; c++) {
+        if (s && this.testEmptyLine(p.data[c])) {
+          _++;
+          continue;
+        }
+        const g = p.data[c].length;
+        if (n += g, typeof m > "u") {
+          m = 0;
+          continue;
+        } else g > 1 && (u += Math.abs(g - m), m = g);
+      }
+      p.data.length > 0 && (n /= p.data.length - _), (typeof f > "u" || u > f) && n > 1.99 && (f = u, h = d);
+    }
+    return this._config.delimiter = h, {
+      successful: !!h,
+      bestDelimiter: h
+    };
+  }
+  addError(e, t, s, i) {
+    this._results.errors.push({
+      type: e,
+      code: t,
+      message: s,
+      row: i
+    });
+  }
+}
+function bt(r, e) {
+  r = r.substr(0, 1024 * 1024);
+  const t = new RegExp(`${V(e)}([^]*?)${V(e)}`, "gm");
+  r = r.replace(t, "");
+  const s = r.split("\r"), i = r.split(`
+`), a = i.length > 1 && i[0].length < s[0].length;
+  if (s.length === 1 || a)
+    return `
+`;
+  let h = 0;
+  for (let f = 0; f < s.length; f++)
+    s[f][0] === `
+` && h++;
+  return h >= s.length / 2 ? `\r
+` : "\r";
+}
+function V(r) {
+  return r.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function Z(r = {}) {
+  let e = r.delimiter, t = r.newline, s = r.comments;
+  const i = r.step, a = r.preview, h = r.fastMode;
+  let f;
+  r.quoteChar === void 0 ? f = '"' : f = r.quoteChar;
+  let m = f;
+  if (r.escapeChar !== void 0 && (m = r.escapeChar), (typeof e != "string" || j.BAD_DELIMITERS.indexOf(e) > -1) && (e = ","), s === e)
+    throw new Error("Comment character same as delimiter");
+  s === !0 ? s = "#" : (typeof s != "string" || j.BAD_DELIMITERS.indexOf(s) > -1) && (s = !1), t !== `
+` && t !== "\r" && t !== `\r
+` && (t = `
+`);
+  let o = 0, d = !1;
+  this.parse = function(n, u, _) {
+    if (typeof n != "string")
+      throw new Error("Input must be a string");
+    const p = n.length, c = e.length, g = t.length, A = s.length, R = x(i);
+    o = 0;
+    let y = [], F = [], w = [], v = 0;
+    if (!n)
+      return E();
+    if (h || h !== !1 && n.indexOf(f) === -1) {
+      const S = n.split(t);
+      for (let O = 0; O < S.length; O++) {
+        const k = S[O];
+        if (o += k.length, O !== S.length - 1)
+          o += t.length;
+        else if (_)
+          return E();
+        if (!(s && k.substr(0, A) === s)) {
+          if (R) {
+            if (y = [], I(k.split(e)), N(), d)
+              return E();
+          } else
+            I(k.split(e));
+          if (a && O >= a)
+            return y = y.slice(0, a), E(!0);
+        }
+      }
+      return E();
+    }
+    let T = n.indexOf(e, o), C = n.indexOf(t, o);
+    const D = new RegExp(V(m) + V(f), "g");
+    let b;
+    for (; ; ) {
+      if (n[o] === f) {
+        for (b = o, o++; ; ) {
+          if (b = n.indexOf(f, b + 1), b === -1)
+            return _ || F.push({
+              type: "Quotes",
+              code: "MissingQuotes",
+              message: "Quoted field unterminated",
+              row: y.length,
+              // row has yet to be inserted
+              index: o
+            }), H();
+          if (b === p - 1) {
+            const De = n.substring(o, b).replace(D, f);
+            return H(De);
+          }
+          if (f === m && n[b + 1] === m) {
+            b++;
+            continue;
+          }
+          if (f !== m && b !== 0 && n[b - 1] === m)
+            continue;
+          const S = C === -1 ? T : Math.min(T, C), O = K(S);
+          if (n[b + 1 + O] === e) {
+            if (w.push(n.substring(o, b).replace(D, f)), o = b + 1 + O + c, T = n.indexOf(e, o), C = n.indexOf(t, o), R && (N(), d))
+              return E();
+            if (a && y.length >= a)
+              return E(!0);
+            break;
+          }
+          const k = K(C);
+          if (n.substr(b + 1 + k, g) === t) {
+            if (w.push(n.substring(o, b).replace(D, f)), G(b + 1 + k + g), T = n.indexOf(e, o), R && (N(), d))
+              return E();
+            if (a && y.length >= a)
+              return E(!0);
+            break;
+          }
+          F.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 (R && (N(), d))
+          return E();
+        if (a && y.length >= a)
+          return E(!0);
+        continue;
+      }
+      if (s && w.length === 0 && n.substr(o, A) === s) {
+        if (C === -1)
+          return E();
+        o = C + g, C = n.indexOf(t, o), T = n.indexOf(e, o);
+        continue;
+      }
+      if (T !== -1 && (T < C || C === -1)) {
+        w.push(n.substring(o, T)), o = T + c, T = n.indexOf(e, o);
+        continue;
+      }
+      if (C !== -1) {
+        if (w.push(n.substring(o, C)), G(C + g), R && (N(), d))
+          return E();
+        if (a && y.length >= a)
+          return E(!0);
+        continue;
+      }
+      break;
+    }
+    return H();
+    function I(S) {
+      y.push(S), v = o;
+    }
+    function K(S) {
+      let O = 0;
+      if (S !== -1) {
+        const k = n.substring(b + 1, S);
+        k && k.trim() === "" && (O = k.length);
+      }
+      return O;
+    }
+    function H(S) {
+      return _ || (typeof S > "u" && (S = n.substr(o)), w.push(S), o = p, I(w), R && N()), E();
+    }
+    function G(S) {
+      o = S, I(w), w = [], C = n.indexOf(t, o);
+    }
+    function E(S, O) {
+      return {
+        data: O || !1 ? y[0] : y,
+        errors: F,
+        meta: {
+          delimiter: e,
+          linebreak: t,
+          aborted: d,
+          truncated: !!S,
+          cursor: v + (u || 0)
+        }
+      };
+    }
+    function N() {
+      i(E(void 0, !0)), y = [], F = [];
+    }
+  }, this.abort = function() {
+    d = !0;
+  }, this.getCharIndex = function() {
+    return o;
+  };
+}
+function Ae(r) {
+  if (typeof r != "object" || r === null)
+    return r;
+  const e = Array.isArray(r) ? [] : {};
+  for (const t in r)
+    e[t] = Ae(r[t]);
+  return e;
+}
+function x(r) {
+  return typeof r == "function";
+}
+function _t(r, e = {}) {
+  let t = !1, s = !0, i = ",", a = `\r
+`, h = '"', f = h + h, m = !1, o = null;
+  n();
+  const d = new RegExp(Ct(h), "g");
+  if (typeof r == "string" && (r = JSON.parse(r)), Array.isArray(r)) {
+    if (!r.length || Array.isArray(r[0]))
+      return u(null, r, m);
+    if (typeof r[0] == "object")
+      return u(o || Object.keys(r[0]), r, m);
+  } else if (typeof r == "object")
+    return typeof r.data == "string" && (r.data = JSON.parse(r.data)), Array.isArray(r.data) && (r.fields || (r.fields = r.meta && r.meta.fields), r.fields || (r.fields = Array.isArray(r.data[0]) ? r.fields : Object.keys(r.data[0])), !Array.isArray(r.data[0]) && typeof r.data[0] != "object" && (r.data = [r.data])), u(r.fields || [], r.data || [], m);
+  throw new Error("Unable to serialize unrecognized input");
+  function n() {
+    if (typeof e == "object") {
+      if (typeof e.delimiter == "string" && !j.BAD_DELIMITERS.filter(function(c) {
+        var g;
+        return ((g = e.delimiter) == null ? void 0 : g.indexOf(c)) !== -1;
+      }).length && (i = e.delimiter), (typeof e.quotes == "boolean" || Array.isArray(e.quotes)) && (t = e.quotes), (typeof e.skipEmptyLines == "boolean" || e.skipEmptyLines === "greedy") && (m = e.skipEmptyLines), typeof e.newline == "string" && (a = e.newline), typeof e.quoteChar == "string" && (h = 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 && (f = e.escapeChar + h);
+    }
+  }
+  function u(c, g, A) {
+    let R = "";
+    typeof c == "string" && (c = JSON.parse(c)), typeof g == "string" && (g = JSON.parse(g));
+    const y = Array.isArray(c) && c.length > 0, F = !Array.isArray(g[0]);
+    if (y && s) {
+      for (let w = 0; w < c.length; w++)
+        w > 0 && (R += i), R += _(c[w], w);
+      g.length > 0 && (R += a);
+    }
+    for (let w = 0; w < g.length; w++) {
+      const v = y ? c.length : g[w].length;
+      let T = !1;
+      const C = y ? Object.keys(g[w]).length === 0 : g[w].length === 0;
+      if (A && !y && (T = A === "greedy" ? g[w].join("").trim() === "" : g[w].length === 1 && g[w][0].length === 0), A === "greedy" && y) {
+        const D = [];
+        for (let b = 0; b < v; b++) {
+          const I = F ? c[b] : b;
+          D.push(g[w][I]);
+        }
+        T = D.join("").trim() === "";
+      }
+      if (!T) {
+        for (let D = 0; D < v; D++) {
+          D > 0 && !C && (R += i);
+          const b = y && F ? c[D] : D;
+          R += _(g[w][b], D);
+        }
+        w < g.length - 1 && (!A || v > 0 && !C) && (R += a);
+      }
+    }
+    return R;
+  }
+  function _(c, g) {
+    return typeof c > "u" || c === null ? "" : c.constructor === Date ? JSON.stringify(c).slice(1, 25) : (c = c.toString().replace(d, f), typeof t == "boolean" && t || Array.isArray(t) && t[g] || p(c, j.BAD_DELIMITERS) || c.indexOf(i) > -1 || c.charAt(0) === " " || c.charAt(c.length - 1) === " " ? h + c + h : c);
+  }
+  function p(c, g) {
+    for (let A = 0; A < g.length; A++)
+      if (c.indexOf(g[A]) > -1)
+        return !0;
+    return !1;
+  }
+}
+function Ct(r) {
+  return r.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const P = {
+  ...j,
+  parse: gt,
+  unparse: _t,
+  ChunkStreamer: _e,
+  // Exposed for testing and development only
+  Parser: Z,
+  ParserHandle: Ce
+}, { ChunkStreamer: At } = P;
+class Tt extends At {
+  constructor(t = {}) {
+    super(t);
+    l(this, "textDecoder", new TextDecoder(this._config.encoding));
+  }
+  // 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(t) {
+    this._input = t;
+    try {
+      for await (const s of t)
+        this.parseChunk(this.getStringChunk(s));
+      this._finished = !0, this.parseChunk("");
+    } catch (s) {
+      this._sendError(s);
+    }
+  }
+  _nextChunk() {
+  }
+  // HELPER METHODS
+  getStringChunk(t) {
+    return typeof t == "string" ? t : this.textDecoder.decode(t, { stream: !0 });
+  }
+}
+const Te = {
+  id: "csv",
+  module: "csv",
+  name: "CSV",
+  extensions: ["csv", "tsv", "dsv"],
+  mimeTypes: ["text/csv", "text/tab-separated-values", "text/dsv"],
+  category: "table"
+}, Rt = "4.4.3", Y = "object-row-table", M = {
+  ...Te,
+  dataType: null,
+  batchType: null,
+  version: Rt,
+  parse: async (r, e) => ne(new TextDecoder().decode(r), e),
+  parseText: (r, e) => ne(r, e),
+  parseInBatches: St,
+  // @ts-ignore
+  // testText: null,
+  options: {
+    csv: {
+      shape: Y,
+      // '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 ne(r, e) {
+  const t = { ...M.options.csv, ...e == null ? void 0 : e.csv }, s = Et(r), a = t.header === "auto" ? Re(s) : !!t.header, h = {
+    // dynamicTyping: true,
+    ...t,
+    header: a,
+    download: !1,
+    // We handle loading, no need for papaparse to do it for us
+    transformHeader: a ? Se() : void 0,
+    error: (u) => {
+      throw new Error(u);
+    }
+  }, f = P.parse(r, h), m = f.data, o = f.meta.fields || Ee(t.columnPrefix, s.length), d = t.shape || Y;
+  let n;
+  switch (d) {
+    case "object-row-table":
+      n = {
+        shape: "object-row-table",
+        data: m.map((u) => Array.isArray(u) ? pe(u, o) : u)
+      };
+      break;
+    case "array-row-table":
+      n = {
+        shape: "array-row-table",
+        data: m.map((u) => Array.isArray(u) ? u : we(u, o))
+      };
+      break;
+    default:
+      throw new Error(d);
+  }
+  return n.schema = me(n), n;
+}
+function St(r, e) {
+  var o;
+  e = { ...e }, ((o = e == null ? void 0 : e.core) == null ? void 0 : o.batchSize) === "auto" && (e.core.batchSize = 4e3);
+  const t = { ...M.options.csv, ...e == null ? void 0 : e.csv }, s = new mt();
+  let i = !0, a = null, h = null, f = null;
+  const m = {
+    // dynamicTyping: true, // Convert numbers and boolean values in rows from strings,
+    ...t,
+    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(d) {
+      let n = d.data;
+      if (t.skipEmptyLines && n.flat().join("").trim() === "")
+        return;
+      const u = d.meta.cursor;
+      if (i && !a && (t.header === "auto" ? Re(n) : !!t.header)) {
+        a = n.map(Se());
+        return;
+      }
+      i && (i = !1, a || (a = Ee(t.columnPrefix, n.length)), f = Bt(n, a)), t.optimizeMemoryUsage && (n = JSON.parse(JSON.stringify(n)));
+      const _ = (e == null ? void 0 : e.shape) || t.shape || Y;
+      h = h || new be(
+        // @ts-expect-error TODO this is not a proper schema
+        f,
+        {
+          shape: _,
+          ...(e == null ? void 0 : e.core) || {}
+        }
+      );
+      try {
+        h.addRow(n);
+        const p = h && h.getFullBatch({ bytesUsed: u });
+        p && s.enqueue(p);
+      } catch (p) {
+        s.enqueue(p);
+      }
+    },
+    // complete is called when all rows have been read
+    complete(d) {
+      try {
+        const n = d.meta.cursor, u = h && h.getFinalBatch({ bytesUsed: n });
+        u && s.enqueue(u);
+      } catch (n) {
+        s.enqueue(n);
+      }
+      s.close();
+    }
+  };
+  return P.parse(je(r), m, Tt), s;
+}
+function Re(r) {
+  return r && r.every((e) => typeof e == "string");
+}
+function Et(r) {
+  return P.parse(r, {
+    dynamicTyping: !0,
+    preview: 1
+  }).data[0];
+}
+function Se() {
+  const r = /* @__PURE__ */ new Set();
+  return (e) => {
+    let t = e, s = 1;
+    for (; r.has(t); )
+      t = `${e}.${s}`, s++;
+    return r.add(t), t;
+  };
+}
+function Ee(r, e = 0) {
+  const t = [];
+  for (let s = 0; s < e; s++)
+    t.push(`${r}${s + 1}`);
+  return t;
+}
+function Bt(r, e) {
+  const t = [];
+  for (let s = 0; s < r.length; s++) {
+    const i = e && e[s] || s, a = r[s];
+    switch (typeof a) {
+      case "number":
+        t.push({ name: String(i), type: "float64", nullable: !0 });
+        break;
+      case "boolean":
+        t.push({ name: String(i), type: "bool", nullable: !0 });
+        break;
+      case "string":
+        t.push({ name: String(i), type: "utf8", nullable: !0 });
+        break;
+      default:
+        xe.warn(`CSV: Unknown column type: ${typeof a}`)(), t.push({ name: String(i), type: "utf8", nullable: !0 });
+    }
+  }
+  return {
+    fields: t,
+    metadata: {
+      "loaders.gl#format": "csv",
+      "loaders.gl#loader": "CSVLoader"
+    }
+  };
+}
+var ie = {}, z = {}, Q = 34, L = 10, J = 13;
+function Be(r) {
+  return new Function("d", "return {" + r.map(function(e, t) {
+    return JSON.stringify(e) + ": d[" + t + '] || ""';
+  }).join(",") + "}");
+}
+function Dt(r, e) {
+  var t = Be(r);
+  return function(s, i) {
+    return e(t(s), i, r);
+  };
+}
+function ae(r) {
+  var e = /* @__PURE__ */ Object.create(null), t = [];
+  return r.forEach(function(s) {
+    for (var i in s)
+      i in e || t.push(e[i] = i);
+  }), t;
+}
+function B(r, e) {
+  var t = r + "", s = t.length;
+  return s < e ? new Array(e - s + 1).join(0) + t : t;
+}
+function Ot(r) {
+  return r < 0 ? "-" + B(-r, 6) : r > 9999 ? "+" + B(r, 6) : B(r, 4);
+}
+function kt(r) {
+  var e = r.getUTCHours(), t = r.getUTCMinutes(), s = r.getUTCSeconds(), i = r.getUTCMilliseconds();
+  return isNaN(r) ? "Invalid Date" : Ot(r.getUTCFullYear()) + "-" + B(r.getUTCMonth() + 1, 2) + "-" + B(r.getUTCDate(), 2) + (i ? "T" + B(e, 2) + ":" + B(t, 2) + ":" + B(s, 2) + "." + B(i, 3) + "Z" : s ? "T" + B(e, 2) + ":" + B(t, 2) + ":" + B(s, 2) + "Z" : t || e ? "T" + B(e, 2) + ":" + B(t, 2) + "Z" : "");
+}
+function vt(r) {
+  var e = new RegExp('["' + r + `
+\r]`), t = r.charCodeAt(0);
+  function s(n, u) {
+    var _, p, c = i(n, function(g, A) {
+      if (_) return _(g, A - 1);
+      p = g, _ = u ? Dt(g, u) : Be(g);
+    });
+    return c.columns = p || [], c;
+  }
+  function i(n, u) {
+    var _ = [], p = n.length, c = 0, g = 0, A, R = p <= 0, y = !1;
+    n.charCodeAt(p - 1) === L && --p, n.charCodeAt(p - 1) === J && --p;
+    function F() {
+      if (R) return z;
+      if (y) return y = !1, ie;
+      var v, T = c, C;
+      if (n.charCodeAt(T) === Q) {
+        for (; c++ < p && n.charCodeAt(c) !== Q || n.charCodeAt(++c) === Q; ) ;
+        return (v = c) >= p ? R = !0 : (C = n.charCodeAt(c++)) === L ? y = !0 : C === J && (y = !0, n.charCodeAt(c) === L && ++c), n.slice(T + 1, v - 1).replace(/""/g, '"');
+      }
+      for (; c < p; ) {
+        if ((C = n.charCodeAt(v = c++)) === L) y = !0;
+        else if (C === J)
+          y = !0, n.charCodeAt(c) === L && ++c;
+        else if (C !== t) continue;
+        return n.slice(T, v);
+      }
+      return R = !0, n.slice(T, p);
+    }
+    for (; (A = F()) !== z; ) {
+      for (var w = []; A !== ie && A !== z; ) w.push(A), A = F();
+      u && (w = u(w, g++)) == null || _.push(w);
+    }
+    return _;
+  }
+  function a(n, u) {
+    return n.map(function(_) {
+      return u.map(function(p) {
+        return d(_[p]);
+      }).join(r);
+    });
+  }
+  function h(n, u) {
+    return u == null && (u = ae(n)), [u.map(d).join(r)].concat(a(n, u)).join(`
+`);
+  }
+  function f(n, u) {
+    return u == null && (u = ae(n)), a(n, u).join(`
+`);
+  }
+  function m(n) {
+    return n.map(o).join(`
+`);
+  }
+  function o(n) {
+    return n.map(d).join(r);
+  }
+  function d(n) {
+    return n == null ? "" : n instanceof Date ? kt(n) : e.test(n += "") ? '"' + n.replace(/"/g, '""') + '"' : n;
+  }
+  return {
+    parse: s,
+    parseRows: i,
+    format: h,
+    formatBody: f,
+    formatRows: m,
+    formatRow: o,
+    formatValue: d
+  };
+}
+var Ft = vt(","), jt = Ft.formatRows;
+function oe(r, e = { csv: { useDisplayNames: !0 } }) {
+  var f, m;
+  const t = e.useDisplayNames || ((f = e.csv) == null ? void 0 : f.useDisplayNames), a = [(((m = r.schema) == null ? void 0 : m.fields) || []).map((o) => {
+    var n;
+    const d = (n = o.metadata) == null ? void 0 : n.displayName;
+    return t && typeof d == "string" ? d : o.name;
+  })];
+  for (const o of ze(r)) {
+    const d = [];
+    for (let n = 0; n < de(r); ++n) {
+      const u = o[n];
+      d[n] = xt(u);
+    }
+    a.push(d);
+  }
+  const h = a.map((o) => o.map((d) => d === null ? "" : d));
+  return jt(h);
+}
+const xt = (r) => r == null ? null : r instanceof Date ? r.toISOString() : typeof r == "object" ? JSON.stringify(r) : String(r), $t = {
+  ...Te,
+  version: "latest",
+  options: {
+    csv: {
+      useDisplayNames: !1
+    }
+  },
+  text: !0,
+  encode: async (r, e) => new TextEncoder().encode(oe(r, e)).buffer,
+  encodeTextSync: (r, e) => oe(r, e)
+}, Pt = {
+  ...M,
+  dataType: null,
+  batchType: null,
+  parse: async (r, e) => le(new TextDecoder().decode(r), e),
+  parseText: (r, e) => le(r, e),
+  parseInBatches: It
+};
+async function le(r, e) {
+  const t = await M.parseText(r, e);
+  return U(t, "arrow-table");
+}
+function It(r, e) {
+  const t = M.parseInBatches(r, e);
+  return at(t, "arrow-table");
+}
+export {
+  Pt as CSVArrowLoader,
+  M as CSVLoader,
+  $t as CSVWriter
+};