@nika-js/onlymap 0.1.0

package/dist/index-BFjXVHly.js

@@ -0,0 +1,605 @@
+var R = Object.defineProperty;
+var N = (t, e, r) => e in t ? R(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var u = (t, e, r) => N(t, typeof e != "symbol" ? e + "" : e, r);
+import { c as W, W as x, d as O, e as _, f as m, h as g, j as P, s as z, n as I, k as B, m as k, o as $, p as C, q as M, r as U, u as F, v as D, w as L, x as j, y as v, z as T, A as J } from "./index-CU-iOTdr.js";
+import { F as Ue, R as De, _ as je, B as ve, C as Je, D as qe, E as Ve, G as Ge, H as He, I as Ke, J as Qe, K as Xe, L as Ye, M as Ze, N as er, O as rr, P as tr, Q as nr, S as ar, T as sr, U as cr, V as or, X as ir, Y as ur, Z as fr } from "./index-CU-iOTdr.js";
+import { g as q, i as V } from "./table-accessors-DBjWgN0C.js";
+async function G(t, e, r = {}, n = {}) {
+  const a = W(t), s = x.getWorkerFarm(r), { source: c } = r, o = { name: a, source: c };
+  c || (o.url = O(t, r));
+  const i = s.getWorkerPool(o), f = r.jobName || t.name, y = await i.startJob(
+    f,
+    // eslint-disable-next-line
+    H.bind(null, n)
+  ), h = _(r);
+  return y.postMessage("process", { input: e, options: h }), (await y.result).result;
+}
+async function H(t, e, r, n) {
+  switch (r) {
+    case "done":
+      e.done(n);
+      break;
+    case "error":
+      e.error(new Error(n.error));
+      break;
+    case "process":
+      const { id: a, input: s, options: c } = n;
+      try {
+        if (!t.process) {
+          e.postMessage("error", { id: a, error: "Worker not set up to process on main thread" });
+          return;
+        }
+        const o = await t.process(s, c);
+        e.postMessage("done", { id: a, result: o });
+      } catch (o) {
+        const i = o instanceof Error ? o.message : "unknown error";
+        e.postMessage("error", { id: a, error: i });
+      }
+      break;
+    default:
+      console.warn(`process-on-worker: unknown message ${r}`);
+  }
+}
+function K(t, e) {
+  var a, s;
+  if (!x.isSupported())
+    return !1;
+  const r = (e == null ? void 0 : e._nodeWorkers) ?? ((a = e == null ? void 0 : e.core) == null ? void 0 : a._nodeWorkers), n = (e == null ? void 0 : e.worker) ?? ((s = e == null ? void 0 : e.core) == null ? void 0 : s.worker);
+  return !m && !r ? !1 : !!(t.worker && n);
+}
+async function* be(t, e = {}) {
+  const r = new TextDecoder(void 0, e);
+  for await (const n of t)
+    yield typeof n == "string" ? n : r.decode(n, { stream: !0 });
+}
+async function* pe(t) {
+  const e = new TextEncoder();
+  for await (const r of t)
+    yield typeof r == "string" ? e.encode(r).buffer : r;
+}
+async function* Se(t) {
+  let e = "";
+  for await (const r of t) {
+    e += r;
+    let n;
+    for (; (n = e.indexOf(`
+`)) >= 0; ) {
+      const a = e.slice(0, n + 1);
+      e = e.slice(n + 1), yield a;
+    }
+  }
+  e.length > 0 && (yield e);
+}
+async function* xe(t) {
+  let e = 1;
+  for await (const r of t)
+    yield { counter: e, line: r }, e++;
+}
+const Q = "4.4.3", Ie = {
+  dataType: null,
+  batchType: null,
+  name: "JSON",
+  id: "json",
+  module: "json",
+  version: Q,
+  extensions: ["json", "geojson"],
+  mimeTypes: ["application/json"],
+  category: "json",
+  text: !0,
+  parseTextSync: b,
+  parse: async (t) => b(new TextDecoder().decode(t)),
+  options: {}
+};
+function b(t) {
+  return JSON.parse(t);
+}
+class X {
+  constructor(e) {
+    u(this, "handle");
+    u(this, "size");
+    u(this, "bigsize");
+    u(this, "url");
+    this.handle = e instanceof ArrayBuffer ? new Blob([e]) : e, this.size = e instanceof ArrayBuffer ? e.byteLength : e.size, this.bigsize = BigInt(this.size), this.url = e instanceof File ? e.name : "";
+  }
+  async close() {
+  }
+  async stat() {
+    return {
+      size: this.handle.size,
+      bigsize: BigInt(this.handle.size),
+      isDirectory: !1
+    };
+  }
+  async read(e, r) {
+    return await this.handle.slice(Number(e), Number(e) + Number(r)).arrayBuffer();
+  }
+}
+const l = new Error("Not implemented");
+class Y {
+  constructor(e, r, n) {
+    u(this, "handle");
+    u(this, "size", 0);
+    u(this, "bigsize", 0n);
+    u(this, "url", "");
+    var a;
+    if ((a = globalThis.loaders) != null && a.NodeFile)
+      return new globalThis.loaders.NodeFile(e, r, n);
+    throw m ? new Error("Can't instantiate NodeFile in browser.") : new Error("Can't instantiate NodeFile. Make sure to import @loaders.gl/polyfills first.");
+  }
+  /** Read data */
+  async read(e, r) {
+    throw l;
+  }
+  /** Write to file. The number of bytes written will be returned */
+  async write(e, r, n) {
+    throw l;
+  }
+  /** Get information about file */
+  async stat() {
+    throw l;
+  }
+  /** Truncates the file descriptor. Only available on NodeFile. */
+  async truncate(e) {
+    throw l;
+  }
+  /** Append data to a file. Only available on NodeFile. */
+  async append(e) {
+    throw l;
+  }
+  /** Close the file */
+  async close() {
+  }
+}
+async function Be(t, e, r) {
+  t instanceof Blob || (t = new Blob([t]));
+  const n = t.slice(e, e + r);
+  return await Z(n);
+}
+async function Z(t) {
+  return await new Promise((e, r) => {
+    const n = new FileReader();
+    n.onload = (a) => {
+      var s;
+      return e((s = a == null ? void 0 : a.target) == null ? void 0 : s.result);
+    }, n.onerror = (a) => r(a), n.readAsArrayBuffer(t);
+  });
+}
+function ke(t, e, r, n) {
+  !Array.isArray(e) && !g(e) && (n = void 0, r = e, e = void 0), r = r || {};
+  const s = P(e, n), c = z(t, s, r);
+  if (!c)
+    return null;
+  const o = I(r, c, s), i = B(t), f = () => {
+    throw new Error("parseSync called parse (which is async");
+  };
+  return n = k({ url: i, _parseSync: f, _parse: f, loaders: e }, o, n || null), ee(c, t, o, n);
+}
+function ee(t, e, r, n) {
+  if (e = $(e, t), t.parseTextSync && typeof e == "string")
+    return t.parseTextSync(e, r);
+  if (t.parseSync && e instanceof ArrayBuffer)
+    return t.parseSync(e, r, n);
+  throw new Error(`${t.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${n.url || ""}`);
+}
+function re(t) {
+  return { ...t, length: q(t), batchType: "data" };
+}
+async function d(t, e, r, n) {
+  const a = Array.isArray(e) ? e : void 0;
+  !Array.isArray(e) && !g(e) && (n = void 0, r = e, e = void 0), t = await t, r = r || {};
+  const s = B(t), c = await C(t, e, r);
+  if (!c)
+    return [];
+  const o = I(r, c, a, s);
+  return n = k({ url: s, _parseInBatches: d, _parse: F, loaders: a }, o, n || null), await te(c, t, o, n);
+}
+async function te(t, e, r, n) {
+  var o;
+  const a = await ne(t, e, r, n);
+  if (!((o = r == null ? void 0 : r.core) != null && o.metadata))
+    return a;
+  const s = {
+    shape: "metadata",
+    batchType: "metadata",
+    metadata: {
+      _loader: t,
+      _context: n
+    },
+    // Populate with some default fields to avoid crashing
+    data: [],
+    bytesUsed: 0
+  };
+  async function* c(i) {
+    yield s, yield* i;
+  }
+  return c(a);
+}
+async function ne(t, e, r, n) {
+  var c;
+  const a = await M(e, r), s = await ce(a, ((c = r == null ? void 0 : r.core) == null ? void 0 : c.transforms) || []);
+  return t.parseInBatches ? t.parseInBatches(s, r, n) : ae(s, t, r, n);
+}
+async function* ae(t, e, r, n) {
+  const a = await U(t), s = await F(
+    a,
+    e,
+    // TODO - Hack: supply loaders MIME type to ensure we match it
+    { ...r, core: { ...r == null ? void 0 : r.core, mimeType: e.mimeTypes[0] } },
+    n
+  );
+  yield se(s, e);
+}
+function se(t, e) {
+  const r = V(t) ? re(t) : {
+    shape: "unknown",
+    batchType: "data",
+    data: t,
+    length: Array.isArray(t) ? t.length : 1
+  };
+  return r.mimeType = e.mimeTypes[0], r;
+}
+async function ce(t, e = []) {
+  let r = t;
+  for await (const n of e)
+    r = n(r);
+  return r;
+}
+function Fe(t, e, r, n) {
+  let a;
+  !Array.isArray(e) && !g(e) ? (r = e, a = void 0) : a = e;
+  const s = D(r || {});
+  return Array.isArray(t) ? t.map((o) => p(o, a, r || {}, s)) : p(t, a, r || {}, s);
+}
+async function p(t, e, r, n) {
+  if (typeof t == "string") {
+    const s = await n(t);
+    return Array.isArray(e) ? await d(s, e, r) : await d(s, e, r);
+  }
+  return Array.isArray(e) ? await d(t, e, r) : await d(t, e, r);
+}
+async function oe(t, e, r) {
+  if (e.encode)
+    return await e.encode(t, r);
+  if (e.encodeText) {
+    const n = await e.encodeText(t, r);
+    return L(new TextEncoder().encode(n));
+  }
+  if (e.encodeInBatches) {
+    const n = ie(t, e, r), a = [];
+    for await (const s of n)
+      a.push(s);
+    return j(...a);
+  }
+  throw new Error("Writer could not encode data");
+}
+async function Le(t, e, r) {
+  if (e.text && e.encodeText)
+    return await e.encodeText(t, r);
+  if (e.text) {
+    const n = await oe(t, e, r);
+    return new TextDecoder().decode(n);
+  }
+  throw new Error(`Writer ${e.name} could not encode data as text`);
+}
+function ie(t, e, r) {
+  if (e.encodeInBatches) {
+    const n = ue(t);
+    return e.encodeInBatches(n, r);
+  }
+  throw new Error("Writer could not encode data in batches");
+}
+function ue(t) {
+  return [{ ...t, start: 0, end: t.length }];
+}
+async function Ae(t, e, r) {
+  const a = { ...v(), ...r };
+  return e.encodeURLtoURL ? de(e, t, a) : K(e, a) ? await G(e, t, a) : await e.encode(t, a);
+}
+function fe(t, e, r) {
+  if (e.encodeSync)
+    return e.encodeSync(t, r);
+  if (e.encodeTextSync)
+    return L(new TextEncoder().encode(e.encodeTextSync(t, r)));
+  throw new Error(`Writer ${e.name} could not synchronously encode data`);
+}
+async function Ee(t, e, r) {
+  if (e.encodeText)
+    return await e.encodeText(t, r);
+  if (e.encodeTextSync)
+    return e.encodeTextSync(t, r);
+  if (e.text) {
+    const n = await e.encode(t, r);
+    return new TextDecoder().decode(n);
+  }
+  throw new Error(`Writer ${e.name} could not encode data as text`);
+}
+function Re(t, e, r) {
+  if (e.encodeTextSync)
+    return e.encodeTextSync(t, r);
+  if (e.text && e.encodeSync) {
+    const n = fe(t, e, r);
+    return new TextDecoder().decode(n);
+  }
+  throw new Error(`Writer ${e.name} could not encode data as text`);
+}
+function Ne(t, e, r) {
+  if (e.encodeInBatches) {
+    const n = ye(t);
+    return e.encodeInBatches(n, r);
+  }
+  throw new Error(`Writer ${e.name} could not encode in batches`);
+}
+async function le(t, e, r, n) {
+  if (t = T(t), e = T(e), m || !r.encodeURLtoURL)
+    throw new Error();
+  return await r.encodeURLtoURL(t, e, n);
+}
+async function de(t, e, r) {
+  if (m)
+    throw new Error(`Writer ${t.name} not supported in browser`);
+  const n = S("input");
+  await new Y(n, "w").write(e);
+  const s = S("output"), c = await le(n, s, t, r);
+  return (await J(c)).arrayBuffer();
+}
+function ye(t) {
+  return [{ ...t, start: 0, end: t.length }];
+}
+function S(t) {
+  return `/tmp/${t}`;
+}
+function We(t, e, r) {
+  const n = (r == null ? void 0 : r.type) || "auto";
+  let a = null;
+  if (n === "auto") {
+    for (const s of e)
+      if (typeof t == "string" && s.testURL && s.testURL(t))
+        return s;
+  } else
+    a = he(n, e);
+  if (!a && !(r != null && r.nothrow))
+    throw new Error("Not a valid image source type");
+  return a;
+}
+function he(t, e) {
+  for (const r of e)
+    if (r.type === t)
+      return r;
+  return null;
+}
+function Oe(t, e) {
+  if (globalThis.loaders.makeNodeStream)
+    return globalThis.loaders.makeNodeStream(t, e);
+  const r = t[Symbol.asyncIterator] ? t[Symbol.asyncIterator]() : t[Symbol.iterator]();
+  return new ReadableStream(
+    {
+      // Create a byte stream (enables `Response(stream).arrayBuffer()`)
+      // Only supported on Chrome
+      // See: https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController
+      // @ts-ignore
+      type: "bytes",
+      async pull(n) {
+        try {
+          const { done: a, value: s } = await r.next();
+          a ? n.close() : n.enqueue(new Uint8Array(s));
+        } catch (a) {
+          n.error(a);
+        }
+      },
+      async cancel() {
+        var n;
+        await ((n = r == null ? void 0 : r.return) == null ? void 0 : n.call(r));
+      }
+    },
+    // options: QueingStrategy<Uint8Array>
+    {
+      // This is bytes, not chunks
+      highWaterMark: 2 ** 24,
+      ...e
+    }
+  );
+}
+const A = "4.4.3", _e = {
+  dataType: null,
+  batchType: null,
+  name: "Null loader",
+  id: "null",
+  module: "core",
+  version: A,
+  worker: !0,
+  mimeTypes: ["application/x.empty"],
+  extensions: ["null"],
+  tests: [() => !1],
+  options: {
+    null: {}
+  }
+}, Pe = {
+  dataType: null,
+  batchType: null,
+  name: "Null loader",
+  id: "null",
+  module: "core",
+  version: A,
+  mimeTypes: ["application/x.empty"],
+  extensions: ["null"],
+  parse: async (t, e, r) => w(),
+  parseSync: w,
+  parseInBatches: async function* (e, r, n) {
+    for await (const a of e)
+      yield w();
+  },
+  tests: [() => !1],
+  options: {
+    null: {}
+  }
+};
+function w(t, e, r) {
+  return null;
+}
+async function ze(t, e, r = () => {
+}, n = () => {
+}) {
+  if (t = await t, !t.ok)
+    return t;
+  const a = t.body;
+  if (!a)
+    return t;
+  const s = t.headers.get("content-length") || 0, c = s ? parseInt(s) : 0;
+  if (!(c > 0) || typeof ReadableStream > "u" || !a.getReader)
+    return t;
+  const o = new ReadableStream({
+    async start(i) {
+      const f = a.getReader();
+      await E(i, f, 0, c, e, r, n);
+    }
+  });
+  return new Response(o);
+}
+async function E(t, e, r, n, a, s, c) {
+  try {
+    const { done: o, value: i } = await e.read();
+    if (o) {
+      s(), t.close();
+      return;
+    }
+    r += i.byteLength;
+    const f = Math.round(r / n * 100);
+    a(f, { loadedBytes: r, totalBytes: n }), t.enqueue(i), await E(t, e, r, n, a, s, c);
+  } catch (o) {
+    t.error(o), c(o);
+  }
+}
+class $e {
+  /**
+   * A FileSystem API wrapper around a list of browser 'File' objects
+   * @param files
+   * @param options
+   */
+  constructor(e, r) {
+    u(this, "_fetch");
+    u(this, "files", {});
+    u(this, "lowerCaseFiles", {});
+    u(this, "usedFiles", {});
+    this._fetch = (r == null ? void 0 : r.fetch) || fetch;
+    for (let n = 0; n < e.length; ++n) {
+      const a = e[n];
+      this.files[a.name] = a, this.lowerCaseFiles[a.name.toLowerCase()] = a, this.usedFiles[a.name] = !1;
+    }
+    this.fetch = this.fetch.bind(this);
+  }
+  // implements IFileSystem
+  /**
+   * Implementation of fetch against this file system
+   * Delegates to global fetch for http{s}:// or data://
+   */
+  async fetch(e, r) {
+    if (e.includes("://"))
+      return this._fetch(e, r);
+    const n = this.files[e];
+    if (!n)
+      return new Response(e, { status: 400, statusText: "NOT FOUND" });
+    const s = new Headers(r == null ? void 0 : r.headers).get("Range"), c = s && /bytes=($1)-($2)/.exec(s);
+    if (c) {
+      const i = parseInt(c[1]), f = parseInt(c[2]), y = await n.slice(i, f).arrayBuffer(), h = new Response(y);
+      return Object.defineProperty(h, "url", { value: e }), h;
+    }
+    const o = new Response(n);
+    return Object.defineProperty(o, "url", { value: e }), o;
+  }
+  /**
+   * List filenames in this filesystem
+   * @param dirname
+   * @returns
+   */
+  async readdir(e) {
+    const r = [];
+    for (const n in this.files)
+      r.push(n);
+    return r;
+  }
+  /**
+   * Return information (size) about files in this file system
+   */
+  async stat(e, r) {
+    const n = this.files[e];
+    if (!n)
+      throw new Error(e);
+    return { size: n.size };
+  }
+  /**
+   * Just removes the file from the list
+   */
+  async unlink(e) {
+    delete this.files[e], delete this.lowerCaseFiles[e], this.usedFiles[e] = !0;
+  }
+  // implements IRandomAccessFileSystem
+  // RANDOM ACCESS
+  async openReadableFile(e, r) {
+    return new X(this.files[e]);
+  }
+  // PRIVATE
+  // Supports case independent paths, and file usage tracking
+  _getFile(e, r) {
+    const n = this.files[e] || this.lowerCaseFiles[e];
+    return n && r && (this.usedFiles[e] = !0), n;
+  }
+}
+export {
+  Ue as FetchError,
+  Ie as JSONLoader,
+  Pe as NullLoader,
+  _e as NullWorkerLoader,
+  De as RequestScheduler,
+  $e as _BrowserFileSystem,
+  ze as _fetchProgress,
+  We as _selectSource,
+  je as _unregisterLoaders,
+  ve as assert,
+  U as concatenateArrayBuffersAsync,
+  Je as createDataSource,
+  qe as document,
+  Ae as encode,
+  Ne as encodeInBatches,
+  fe as encodeSync,
+  oe as encodeTable,
+  Le as encodeTableAsText,
+  ie as encodeTableInBatches,
+  Ee as encodeText,
+  Re as encodeTextSync,
+  le as encodeURLtoURL,
+  J as fetchFile,
+  Ve as forEach,
+  v as getLoaderOptions,
+  Ge as getPathPrefix,
+  He as global,
+  Ke as isAsyncIterable,
+  m as isBrowser,
+  Qe as isIterable,
+  Xe as isIterator,
+  Ye as isPromise,
+  Ze as isPureObject,
+  er as isReadableStream,
+  rr as isResponse,
+  tr as isWorker,
+  nr as isWritableStream,
+  ar as load,
+  Fe as loadInBatches,
+  sr as makeIterator,
+  Se as makeLineIterator,
+  xe as makeNumberedLineIterator,
+  Oe as makeStream,
+  be as makeTextDecoderIterator,
+  pe as makeTextEncoderIterator,
+  F as parse,
+  d as parseInBatches,
+  ke as parseSync,
+  Be as readArrayBuffer,
+  cr as registerLoaders,
+  T as resolvePath,
+  C as selectLoader,
+  z as selectLoaderSync,
+  or as self,
+  ir as setLoaderOptions,
+  ur as setPathPrefix,
+  fr as window
+};