@loaders.gl/json 3.1.0-alpha.3 → 3.1.0-beta.2

package/dist/es5/lib/jsonpath/jsonpath.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/jsonpath/jsonpath.ts"],"names":["JSONPath","constructor","path","Array","isArray","push","split","Error","clone","toString","join","name","pop","set","length","equals","other","i","setFieldAtPath","object","value","shift","field","component","getFieldAtPath"],"mappings":";;;;;;;;;;;AAQe,MAAMA,QAAN,CAAe;AAG5BC,EAAAA,WAAW,CAACC,IAAyC,GAAG,IAA7C,EAAmD;AAAA;AAC5D,SAAKA,IAAL,GAAY,CAAC,GAAD,CAAZ;;AAEA,QAAIA,IAAI,YAAYF,QAApB,EAA8B;AAE5B,WAAKE,IAAL,GAAY,CAAC,GAAGA,IAAI,CAACA,IAAT,CAAZ;AACA;AACD;;AAED,QAAIC,KAAK,CAACC,OAAN,CAAcF,IAAd,CAAJ,EAAyB;AACvB,WAAKA,IAAL,CAAUG,IAAV,CAAe,GAAGH,IAAlB;AACA;AACD;;AAGD,QAAI,OAAOA,IAAP,KAAgB,QAApB,EAA8B;AAC5B,WAAKA,IAAL,GAAYA,IAAI,CAACI,KAAL,CAAW,GAAX,CAAZ;;AACA,UAAI,KAAKJ,IAAL,CAAU,CAAV,MAAiB,GAArB,EAA0B;AACxB,cAAM,IAAIK,KAAJ,CAAU,6BAAV,CAAN;AACD;AACF;AACF;;AAEDC,EAAAA,KAAK,GAAa;AAChB,WAAO,IAAIR,QAAJ,CAAa,IAAb,CAAP;AACD;;AAEDS,EAAAA,QAAQ,GAAW;AACjB,WAAO,KAAKP,IAAL,CAAUQ,IAAV,CAAe,GAAf,CAAP;AACD;;AAEDL,EAAAA,IAAI,CAACM,IAAD,EAAqB;AACvB,SAAKT,IAAL,CAAUG,IAAV,CAAeM,IAAf;AACD;;AAEDC,EAAAA,GAAG,GAAG;AACJ,WAAO,KAAKV,IAAL,CAAUU,GAAV,EAAP;AACD;;AAEDC,EAAAA,GAAG,CAACF,IAAD,EAAqB;AACtB,SAAKT,IAAL,CAAU,KAAKA,IAAL,CAAUY,MAAV,GAAmB,CAA7B,IAAkCH,IAAlC;AACD;;AAEDI,EAAAA,MAAM,CAACC,KAAD,EAA2B;AAC/B,QAAI,CAAC,IAAD,IAAS,CAACA,KAAV,IAAmB,KAAKd,IAAL,CAAUY,MAAV,KAAqBE,KAAK,CAACd,IAAN,CAAWY,MAAvD,EAA+D;AAC7D,aAAO,KAAP;AACD;;AAED,SAAK,IAAIG,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,KAAKf,IAAL,CAAUY,MAA9B,EAAsC,EAAEG,CAAxC,EAA2C;AACzC,UAAI,KAAKf,IAAL,CAAUe,CAAV,MAAiBD,KAAK,CAACd,IAAN,CAAWe,CAAX,CAArB,EAAoC;AAClC,eAAO,KAAP;AACD;AACF;;AAED,WAAO,IAAP;AACD;;AAQDC,EAAAA,cAAc,CAACC,MAAD,EAASC,KAAT,EAAgB;AAC5B,UAAMlB,IAAI,GAAG,CAAC,GAAG,KAAKA,IAAT,CAAb;AACAA,IAAAA,IAAI,CAACmB,KAAL;AACA,UAAMC,KAAK,GAAGpB,IAAI,CAACU,GAAL,EAAd;;AACA,SAAK,MAAMW,SAAX,IAAwBrB,IAAxB,EAA8B;AAC5BiB,MAAAA,MAAM,GAAGA,MAAM,CAACI,SAAD,CAAf;AACD;;AAEDJ,IAAAA,MAAM,CAACG,KAAD,CAAN,GAAgBF,KAAhB;AACD;;AAODI,EAAAA,cAAc,CAACL,MAAD,EAAS;AACrB,UAAMjB,IAAI,GAAG,CAAC,GAAG,KAAKA,IAAT,CAAb;AACAA,IAAAA,IAAI,CAACmB,KAAL;AACA,UAAMC,KAAK,GAAGpB,IAAI,CAACU,GAAL,EAAd;;AACA,SAAK,MAAMW,SAAX,IAAwBrB,IAAxB,EAA8B;AAC5BiB,MAAAA,MAAM,GAAGA,MAAM,CAACI,SAAD,CAAf;AACD;;AAED,WAAOJ,MAAM,CAACG,KAAD,CAAb;AACD;;AA3F2B","sourcesContent":["/**\n * A parser for a minimal subset of the jsonpath standard\n * Full JSON path parsers for JS exist but are quite large (bundle size)\n *\n * Supports\n *\n *   `$.component.component.component`\n */\nexport default class JSONPath {\n  path: string[];\n\n  constructor(path: JSONPath | string[] | string | null = null) {\n    this.path = ['$'];\n\n    if (path instanceof JSONPath) {\n      // @ts-ignore\n      this.path = [...path.path];\n      return;\n    }\n\n    if (Array.isArray(path)) {\n      this.path.push(...path);\n      return;\n    }\n\n    // Parse a string as a JSONPath\n    if (typeof path === 'string') {\n      this.path = path.split('.');\n      if (this.path[0] !== '$') {\n        throw new Error('JSONPaths must start with $');\n      }\n    }\n  }\n\n  clone(): JSONPath {\n    return new JSONPath(this);\n  }\n\n  toString(): string {\n    return this.path.join('.');\n  }\n\n  push(name: string): void {\n    this.path.push(name);\n  }\n\n  pop() {\n    return this.path.pop();\n  }\n\n  set(name: string): void {\n    this.path[this.path.length - 1] = name;\n  }\n\n  equals(other: JSONPath): boolean {\n    if (!this || !other || this.path.length !== other.path.length) {\n      return false;\n    }\n\n    for (let i = 0; i < this.path.length; ++i) {\n      if (this.path[i] !== other.path[i]) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Sets the value pointed at by path\n   * TODO - handle root path\n   * @param object\n   * @param value\n   */\n  setFieldAtPath(object, value) {\n    const path = [...this.path];\n    path.shift();\n    const field = path.pop();\n    for (const component of path) {\n      object = object[component];\n    }\n    // @ts-ignore\n    object[field] = value;\n  }\n\n  /**\n   * Gets the value pointed at by path\n   * TODO - handle root path\n   * @param object\n   */\n  getFieldAtPath(object) {\n    const path = [...this.path];\n    path.shift();\n    const field = path.pop();\n    for (const component of path) {\n      object = object[component];\n    }\n    // @ts-ignore\n    return object[field];\n  }\n}\n"],"file":"jsonpath.js"}

package/dist/es5/lib/parse-json-in-batches.js

@@ -0,0 +1,99 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseJSONInBatches;
+
+var _schema = require("@loaders.gl/schema");
+
+var _loaderUtils = require("@loaders.gl/loader-utils");
+
+var _streamingJsonParser = _interopRequireDefault(require("./parser/streaming-json-parser"));
+
+async function* parseJSONInBatches(binaryAsyncIterator, options) {
+  var _options$json;
+
+  const asyncIterator = (0, _loaderUtils.makeTextDecoderIterator)(binaryAsyncIterator);
+  const {
+    metadata
+  } = options;
+  const {
+    jsonpaths
+  } = options.json || {};
+  let isFirstChunk = true;
+  const schema = null;
+  const shape = (options === null || options === void 0 ? void 0 : (_options$json = options.json) === null || _options$json === void 0 ? void 0 : _options$json.shape) || 'row-table';
+  const tableBatchBuilder = new _schema.TableBatchBuilder(schema, { ...options,
+    shape
+  });
+  const parser = new _streamingJsonParser.default({
+    jsonpaths
+  });
+
+  for await (const chunk of asyncIterator) {
+    const rows = parser.write(chunk);
+    const jsonpath = rows.length > 0 && parser.getStreamingJsonPathAsString();
+
+    if (rows.length > 0 && isFirstChunk) {
+      if (metadata) {
+        const initialBatch = {
+          shape,
+          batchType: 'partial-result',
+          data: [],
+          length: 0,
+          bytesUsed: 0,
+          container: parser.getPartialResult(),
+          jsonpath
+        };
+        yield initialBatch;
+      }
+
+      isFirstChunk = false;
+    }
+
+    for (const row of rows) {
+      tableBatchBuilder.addRow(row);
+      const batch = tableBatchBuilder.getFullBatch({
+        jsonpath
+      });
+
+      if (batch) {
+        yield batch;
+      }
+    }
+
+    tableBatchBuilder.chunkComplete(chunk);
+    const batch = tableBatchBuilder.getFullBatch({
+      jsonpath
+    });
+
+    if (batch) {
+      yield batch;
+    }
+  }
+
+  const jsonpath = parser.getStreamingJsonPathAsString();
+  const batch = tableBatchBuilder.getFinalBatch({
+    jsonpath
+  });
+
+  if (batch) {
+    yield batch;
+  }
+
+  if (metadata) {
+    const finalBatch = {
+      shape,
+      batchType: 'final-result',
+      container: parser.getPartialResult(),
+      jsonpath: parser.getStreamingJsonPathAsString(),
+      data: [],
+      length: 0
+    };
+    yield finalBatch;
+  }
+}
+//# sourceMappingURL=parse-json-in-batches.js.map

package/dist/es5/lib/parse-json-in-batches.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/parse-json-in-batches.ts"],"names":["parseJSONInBatches","binaryAsyncIterator","options","asyncIterator","metadata","jsonpaths","json","isFirstChunk","schema","shape","tableBatchBuilder","TableBatchBuilder","parser","StreamingJSONParser","chunk","rows","write","jsonpath","length","getStreamingJsonPathAsString","initialBatch","batchType","data","bytesUsed","container","getPartialResult","row","addRow","batch","getFullBatch","chunkComplete","getFinalBatch","finalBatch"],"mappings":";;;;;;;;;AAEA;;AACA;;AACA;;AAIe,gBAAgBA,kBAAhB,CACbC,mBADa,EAEbC,OAFa,EAGS;AAAA;;AACtB,QAAMC,aAAa,GAAG,0CAAwBF,mBAAxB,CAAtB;AAEA,QAAM;AAACG,IAAAA;AAAD,MAAaF,OAAnB;AACA,QAAM;AAACG,IAAAA;AAAD,MAAcH,OAAO,CAACI,IAAR,IAAgB,EAApC;AAEA,MAAIC,YAAqB,GAAG,IAA5B;AAGA,QAAMC,MAAM,GAAG,IAAf;AACA,QAAMC,KAAK,GAAG,CAAAP,OAAO,SAAP,IAAAA,OAAO,WAAP,6BAAAA,OAAO,CAAEI,IAAT,gEAAeG,KAAf,KAAwB,WAAtC;AAEA,QAAMC,iBAAiB,GAAG,IAAIC,yBAAJ,CAAsBH,MAAtB,EAA8B,EACtD,GAAGN,OADmD;AAEtDO,IAAAA;AAFsD,GAA9B,CAA1B;AAKA,QAAMG,MAAM,GAAG,IAAIC,4BAAJ,CAAwB;AAACR,IAAAA;AAAD,GAAxB,CAAf;;AAEA,aAAW,MAAMS,KAAjB,IAA0BX,aAA1B,EAAyC;AACvC,UAAMY,IAAI,GAAGH,MAAM,CAACI,KAAP,CAAaF,KAAb,CAAb;AAEA,UAAMG,QAAQ,GAAGF,IAAI,CAACG,MAAL,GAAc,CAAd,IAAmBN,MAAM,CAACO,4BAAP,EAApC;;AAEA,QAAIJ,IAAI,CAACG,MAAL,GAAc,CAAd,IAAmBX,YAAvB,EAAqC;AACnC,UAAIH,QAAJ,EAAc;AACZ,cAAMgB,YAAmB,GAAG;AAE1BX,UAAAA,KAF0B;AAG1BY,UAAAA,SAAS,EAAE,gBAHe;AAI1BC,UAAAA,IAAI,EAAE,EAJoB;AAK1BJ,UAAAA,MAAM,EAAE,CALkB;AAM1BK,UAAAA,SAAS,EAAE,CANe;AAQ1BC,UAAAA,SAAS,EAAEZ,MAAM,CAACa,gBAAP,EARe;AAS1BR,UAAAA;AAT0B,SAA5B;AAWA,cAAMG,YAAN;AACD;;AACDb,MAAAA,YAAY,GAAG,KAAf;AAED;;AAGD,SAAK,MAAMmB,GAAX,IAAkBX,IAAlB,EAAwB;AACtBL,MAAAA,iBAAiB,CAACiB,MAAlB,CAAyBD,GAAzB;AAEA,YAAME,KAAK,GAAGlB,iBAAiB,CAACmB,YAAlB,CAA+B;AAACZ,QAAAA;AAAD,OAA/B,CAAd;;AACA,UAAIW,KAAJ,EAAW;AACT,cAAMA,KAAN;AACD;AACF;;AAEDlB,IAAAA,iBAAiB,CAACoB,aAAlB,CAAgChB,KAAhC;AACA,UAAMc,KAAK,GAAGlB,iBAAiB,CAACmB,YAAlB,CAA+B;AAACZ,MAAAA;AAAD,KAA/B,CAAd;;AACA,QAAIW,KAAJ,EAAW;AACT,YAAMA,KAAN;AACD;AACF;;AAGD,QAAMX,QAAQ,GAAGL,MAAM,CAACO,4BAAP,EAAjB;AACA,QAAMS,KAAK,GAAGlB,iBAAiB,CAACqB,aAAlB,CAAgC;AAACd,IAAAA;AAAD,GAAhC,CAAd;;AACA,MAAIW,KAAJ,EAAW;AACT,UAAMA,KAAN;AACD;;AAED,MAAIxB,QAAJ,EAAc;AACZ,UAAM4B,UAAiB,GAAG;AACxBvB,MAAAA,KADwB;AAExBY,MAAAA,SAAS,EAAE,cAFa;AAGxBG,MAAAA,SAAS,EAAEZ,MAAM,CAACa,gBAAP,EAHa;AAIxBR,MAAAA,QAAQ,EAAEL,MAAM,CAACO,4BAAP,EAJc;AAKxBG,MAAAA,IAAI,EAAE,EALkB;AAMxBJ,MAAAA,MAAM,EAAE;AANgB,KAA1B;AASA,UAAMc,UAAN;AACD;AACF","sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport type {JSONLoaderOptions} from '../json-loader';\nimport {TableBatchBuilder} from '@loaders.gl/schema';\nimport {makeTextDecoderIterator} from '@loaders.gl/loader-utils';\nimport StreamingJSONParser from './parser/streaming-json-parser';\n\n// TODO - support batch size 0 = no batching/single batch?\n// eslint-disable-next-line max-statements, complexity\nexport default async function* parseJSONInBatches(\n  binaryAsyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options: JSONLoaderOptions\n): AsyncIterable<Batch> {\n  const asyncIterator = makeTextDecoderIterator(binaryAsyncIterator);\n\n  const {metadata} = options;\n  const {jsonpaths} = options.json || {};\n\n  let isFirstChunk: boolean = true;\n\n  // TODO fix Schema deduction\n  const schema = null; // new Schema([]);\n  const shape = options?.json?.shape || 'row-table';\n  // @ts-ignore\n  const tableBatchBuilder = new TableBatchBuilder(schema, {\n    ...options,\n    shape\n  });\n\n  const parser = new StreamingJSONParser({jsonpaths});\n\n  for await (const chunk of asyncIterator) {\n    const rows = parser.write(chunk);\n\n    const jsonpath = rows.length > 0 && parser.getStreamingJsonPathAsString();\n\n    if (rows.length > 0 && isFirstChunk) {\n      if (metadata) {\n        const initialBatch: Batch = {\n          // Common fields\n          shape,\n          batchType: 'partial-result',\n          data: [],\n          length: 0,\n          bytesUsed: 0,\n          // JSON additions\n          container: parser.getPartialResult(),\n          jsonpath\n        };\n        yield initialBatch;\n      }\n      isFirstChunk = false;\n      // schema = deduceSchema(rows);\n    }\n\n    // Add the row\n    for (const row of rows) {\n      tableBatchBuilder.addRow(row);\n      // If a batch has been completed, emit it\n      const batch = tableBatchBuilder.getFullBatch({jsonpath});\n      if (batch) {\n        yield batch;\n      }\n    }\n\n    tableBatchBuilder.chunkComplete(chunk);\n    const batch = tableBatchBuilder.getFullBatch({jsonpath});\n    if (batch) {\n      yield batch;\n    }\n  }\n\n  // yield final batch\n  const jsonpath = parser.getStreamingJsonPathAsString();\n  const batch = tableBatchBuilder.getFinalBatch({jsonpath});\n  if (batch) {\n    yield batch;\n  }\n\n  if (metadata) {\n    const finalBatch: Batch = {\n      shape,\n      batchType: 'final-result',\n      container: parser.getPartialResult(),\n      jsonpath: parser.getStreamingJsonPathAsString(),\n      data: [],\n      length: 0\n      // schema: null\n    };\n    yield finalBatch;\n  }\n}\n"],"file":"parse-json-in-batches.js"}

package/dist/es5/lib/parse-json.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseJSONSync;
+
+function parseJSONSync(jsonText, options) {
+  try {
+    var _options$json;
+
+    const json = JSON.parse(jsonText);
+
+    if ((_options$json = options.json) !== null && _options$json !== void 0 && _options$json.table) {
+      return getFirstArray(json) || json;
+    }
+
+    return json;
+  } catch (error) {
+    throw new Error('JSONLoader: failed to parse JSON');
+  }
+}
+
+function getFirstArray(json) {
+  if (Array.isArray(json)) {
+    return json;
+  }
+
+  if (json && typeof json === 'object') {
+    for (const value of Object.values(json)) {
+      const array = getFirstArray(value);
+
+      if (array) {
+        return array;
+      }
+    }
+  }
+
+  return null;
+}
+//# sourceMappingURL=parse-json.js.map

package/dist/es5/lib/parse-json.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/parse-json.ts"],"names":["parseJSONSync","jsonText","options","json","JSON","parse","table","getFirstArray","error","Error","Array","isArray","value","Object","values","array"],"mappings":";;;;;;;AAEe,SAASA,aAAT,CAAuBC,QAAvB,EAAyCC,OAAzC,EAAqE;AAClF,MAAI;AAAA;;AACF,UAAMC,IAAI,GAAGC,IAAI,CAACC,KAAL,CAAWJ,QAAX,CAAb;;AACA,yBAAIC,OAAO,CAACC,IAAZ,0CAAI,cAAcG,KAAlB,EAAyB;AACvB,aAAOC,aAAa,CAACJ,IAAD,CAAb,IAAuBA,IAA9B;AACD;;AACD,WAAOA,IAAP;AACD,GAND,CAME,OAAOK,KAAP,EAAc;AACd,UAAM,IAAIC,KAAJ,CAAU,kCAAV,CAAN;AACD;AACF;;AAED,SAASF,aAAT,CAAuBJ,IAAvB,EAA6B;AAC3B,MAAIO,KAAK,CAACC,OAAN,CAAcR,IAAd,CAAJ,EAAyB;AACvB,WAAOA,IAAP;AACD;;AACD,MAAIA,IAAI,IAAI,OAAOA,IAAP,KAAgB,QAA5B,EAAsC;AACpC,SAAK,MAAMS,KAAX,IAAoBC,MAAM,CAACC,MAAP,CAAcX,IAAd,CAApB,EAAyC;AACvC,YAAMY,KAAK,GAAGR,aAAa,CAACK,KAAD,CAA3B;;AACA,UAAIG,KAAJ,EAAW;AACT,eAAOA,KAAP;AACD;AACF;AACF;;AACD,SAAO,IAAP;AACD","sourcesContent":["import type {JSONLoaderOptions} from '../json-loader';\n\nexport default function parseJSONSync(jsonText: string, options: JSONLoaderOptions) {\n  try {\n    const json = JSON.parse(jsonText);\n    if (options.json?.table) {\n      return getFirstArray(json) || json;\n    }\n    return json;\n  } catch (error) {\n    throw new Error('JSONLoader: failed to parse JSON');\n  }\n}\n\nfunction getFirstArray(json) {\n  if (Array.isArray(json)) {\n    return json;\n  }\n  if (json && typeof json === 'object') {\n    for (const value of Object.values(json)) {\n      const array = getFirstArray(value);\n      if (array) {\n        return array;\n      }\n    }\n  }\n  return null;\n}\n"],"file":"parse-json.js"}

package/dist/es5/lib/parse-ndjson-in-batches.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseNDJSONInBatches;
+
+var _schema = require("@loaders.gl/schema");
+
+var _loaderUtils = require("@loaders.gl/loader-utils");
+
+async function* parseNDJSONInBatches(binaryAsyncIterator, options) {
+  const textIterator = (0, _loaderUtils.makeTextDecoderIterator)(binaryAsyncIterator);
+  const lineIterator = (0, _loaderUtils.makeLineIterator)(textIterator);
+  const numberedLineIterator = (0, _loaderUtils.makeNumberedLineIterator)(lineIterator);
+  const schema = null;
+  const shape = 'row-table';
+  const tableBatchBuilder = new _schema.TableBatchBuilder(schema, { ...options,
+    shape
+  });
+
+  for await (const {
+    counter,
+    line
+  } of numberedLineIterator) {
+    try {
+      const row = JSON.parse(line);
+      tableBatchBuilder.addRow(row);
+      tableBatchBuilder.chunkComplete(line);
+      const batch = tableBatchBuilder.getFullBatch();
+
+      if (batch) {
+        yield batch;
+      }
+    } catch (error) {
+      throw new Error("NDJSONLoader: failed to parse JSON on line ".concat(counter));
+    }
+  }
+
+  const batch = tableBatchBuilder.getFinalBatch();
+
+  if (batch) {
+    yield batch;
+  }
+}
+//# sourceMappingURL=parse-ndjson-in-batches.js.map

package/dist/es5/lib/parse-ndjson-in-batches.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/parse-ndjson-in-batches.ts"],"names":["parseNDJSONInBatches","binaryAsyncIterator","options","textIterator","lineIterator","numberedLineIterator","schema","shape","tableBatchBuilder","TableBatchBuilder","counter","line","row","JSON","parse","addRow","chunkComplete","batch","getFullBatch","error","Error","getFinalBatch"],"mappings":";;;;;;;AACA;;AACA;;AAOe,gBAAgBA,oBAAhB,CACbC,mBADa,EAEbC,OAFa,EAGS;AACtB,QAAMC,YAAY,GAAG,0CAAwBF,mBAAxB,CAArB;AACA,QAAMG,YAAY,GAAG,mCAAiBD,YAAjB,CAArB;AACA,QAAME,oBAAoB,GAAG,2CAAyBD,YAAzB,CAA7B;AAEA,QAAME,MAAM,GAAG,IAAf;AACA,QAAMC,KAAK,GAAG,WAAd;AAEA,QAAMC,iBAAiB,GAAG,IAAIC,yBAAJ,CAAsBH,MAAtB,EAA8B,EACtD,GAAGJ,OADmD;AAEtDK,IAAAA;AAFsD,GAA9B,CAA1B;;AAKA,aAAW,MAAM;AAACG,IAAAA,OAAD;AAAUC,IAAAA;AAAV,GAAjB,IAAoCN,oBAApC,EAA0D;AACxD,QAAI;AACF,YAAMO,GAAG,GAAGC,IAAI,CAACC,KAAL,CAAWH,IAAX,CAAZ;AACAH,MAAAA,iBAAiB,CAACO,MAAlB,CAAyBH,GAAzB;AACAJ,MAAAA,iBAAiB,CAACQ,aAAlB,CAAgCL,IAAhC;AACA,YAAMM,KAAK,GAAGT,iBAAiB,CAACU,YAAlB,EAAd;;AACA,UAAID,KAAJ,EAAW;AACT,cAAMA,KAAN;AACD;AACF,KARD,CAQE,OAAOE,KAAP,EAAc;AACd,YAAM,IAAIC,KAAJ,sDAAwDV,OAAxD,EAAN;AACD;AACF;;AAED,QAAMO,KAAK,GAAGT,iBAAiB,CAACa,aAAlB,EAAd;;AACA,MAAIJ,KAAJ,EAAW;AACT,UAAMA,KAAN;AACD;AACF","sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport {TableBatchBuilder} from '@loaders.gl/schema';\nimport {\n  LoaderOptions,\n  makeLineIterator,\n  makeNumberedLineIterator,\n  makeTextDecoderIterator\n} from '@loaders.gl/loader-utils';\n\nexport default async function* parseNDJSONInBatches(\n  binaryAsyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options?: LoaderOptions\n): AsyncIterable<Batch> {\n  const textIterator = makeTextDecoderIterator(binaryAsyncIterator);\n  const lineIterator = makeLineIterator(textIterator);\n  const numberedLineIterator = makeNumberedLineIterator(lineIterator);\n\n  const schema = null;\n  const shape = 'row-table';\n  // @ts-ignore\n  const tableBatchBuilder = new TableBatchBuilder(schema, {\n    ...options,\n    shape\n  });\n\n  for await (const {counter, line} of numberedLineIterator) {\n    try {\n      const row = JSON.parse(line);\n      tableBatchBuilder.addRow(row);\n      tableBatchBuilder.chunkComplete(line);\n      const batch = tableBatchBuilder.getFullBatch();\n      if (batch) {\n        yield batch;\n      }\n    } catch (error) {\n      throw new Error(`NDJSONLoader: failed to parse JSON on line ${counter}`);\n    }\n  }\n\n  const batch = tableBatchBuilder.getFinalBatch();\n  if (batch) {\n    yield batch;\n  }\n}\n"],"file":"parse-ndjson-in-batches.js"}

package/dist/es5/lib/parse-ndjson.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseNDJSONSync;
+
+function parseNDJSONSync(ndjsonText) {
+  const lines = ndjsonText.trim().split('\n');
+  return lines.map((line, counter) => {
+    try {
+      return JSON.parse(line);
+    } catch (error) {
+      throw new Error("NDJSONLoader: failed to parse JSON on line ".concat(counter + 1));
+    }
+  });
+}
+//# sourceMappingURL=parse-ndjson.js.map

package/dist/es5/lib/parse-ndjson.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/parse-ndjson.ts"],"names":["parseNDJSONSync","ndjsonText","lines","trim","split","map","line","counter","JSON","parse","error","Error"],"mappings":";;;;;;;AAAe,SAASA,eAAT,CAAyBC,UAAzB,EAA6C;AAC1D,QAAMC,KAAK,GAAGD,UAAU,CAACE,IAAX,GAAkBC,KAAlB,CAAwB,IAAxB,CAAd;AACA,SAAOF,KAAK,CAACG,GAAN,CAAU,CAACC,IAAD,EAAOC,OAAP,KAAmB;AAClC,QAAI;AACF,aAAOC,IAAI,CAACC,KAAL,CAAWH,IAAX,CAAP;AACD,KAFD,CAEE,OAAOI,KAAP,EAAc;AACd,YAAM,IAAIC,KAAJ,sDAAwDJ,OAAO,GAAG,CAAlE,EAAN;AACD;AACF,GANM,CAAP;AAOD","sourcesContent":["export default function parseNDJSONSync(ndjsonText: string) {\n  const lines = ndjsonText.trim().split('\\n');\n  return lines.map((line, counter) => {\n    try {\n      return JSON.parse(line);\n    } catch (error) {\n      throw new Error(`NDJSONLoader: failed to parse JSON on line ${counter + 1}`);\n    }\n  });\n}\n"],"file":"parse-ndjson.js"}

package/dist/es5/lib/parser/json-parser.js

@@ -0,0 +1,137 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _clarinet = _interopRequireDefault(require("../clarinet/clarinet"));
+
+var _jsonpath = _interopRequireDefault(require("../jsonpath/jsonpath"));
+
+class JSONParser {
+  constructor(options) {
+    (0, _defineProperty2.default)(this, "parser", void 0);
+    (0, _defineProperty2.default)(this, "result", undefined);
+    (0, _defineProperty2.default)(this, "previousStates", []);
+    (0, _defineProperty2.default)(this, "currentState", Object.freeze({
+      container: [],
+      key: null
+    }));
+    (0, _defineProperty2.default)(this, "jsonpath", new _jsonpath.default());
+    this.reset();
+    this.parser = new _clarinet.default({
+      onready: () => {
+        this.jsonpath = new _jsonpath.default();
+        this.previousStates.length = 0;
+        this.currentState.container.length = 0;
+      },
+      onopenobject: name => {
+        this._openObject({});
+
+        if (typeof name !== 'undefined') {
+          this.parser.emit('onkey', name);
+        }
+      },
+      onkey: name => {
+        this.jsonpath.set(name);
+        this.currentState.key = name;
+      },
+      oncloseobject: () => {
+        this._closeObject();
+      },
+      onopenarray: () => {
+        this._openArray();
+      },
+      onclosearray: () => {
+        this._closeArray();
+      },
+      onvalue: value => {
+        this._pushOrSet(value);
+      },
+      onerror: error => {
+        throw error;
+      },
+      onend: () => {
+        this.result = this.currentState.container.pop();
+      },
+      ...options
+    });
+  }
+
+  reset() {
+    this.result = undefined;
+    this.previousStates = [];
+    this.currentState = Object.freeze({
+      container: [],
+      key: null
+    });
+    this.jsonpath = new _jsonpath.default();
+  }
+
+  write(chunk) {
+    this.parser.write(chunk);
+  }
+
+  close() {
+    this.parser.close();
+  }
+
+  _pushOrSet(value) {
+    const {
+      container,
+      key
+    } = this.currentState;
+
+    if (key !== null) {
+      container[key] = value;
+      this.currentState.key = null;
+    } else {
+      container.push(value);
+    }
+  }
+
+  _openArray(newContainer = []) {
+    this.jsonpath.push(null);
+
+    this._pushOrSet(newContainer);
+
+    this.previousStates.push(this.currentState);
+    this.currentState = {
+      container: newContainer,
+      isArray: true,
+      key: null
+    };
+  }
+
+  _closeArray() {
+    this.jsonpath.pop();
+    this.currentState = this.previousStates.pop();
+  }
+
+  _openObject(newContainer = {}) {
+    this.jsonpath.push(null);
+
+    this._pushOrSet(newContainer);
+
+    this.previousStates.push(this.currentState);
+    this.currentState = {
+      container: newContainer,
+      isArray: false,
+      key: null
+    };
+  }
+
+  _closeObject() {
+    this.jsonpath.pop();
+    this.currentState = this.previousStates.pop();
+  }
+
+}
+
+exports.default = JSONParser;
+//# sourceMappingURL=json-parser.js.map

package/dist/es5/lib/parser/json-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/parser/json-parser.ts"],"names":["JSONParser","constructor","options","undefined","Object","freeze","container","key","JSONPath","reset","parser","ClarinetParser","onready","jsonpath","previousStates","length","currentState","onopenobject","name","_openObject","emit","onkey","set","oncloseobject","_closeObject","onopenarray","_openArray","onclosearray","_closeArray","onvalue","value","_pushOrSet","onerror","error","onend","result","pop","write","chunk","close","push","newContainer","isArray"],"mappings":"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","sourcesContent":["// @ts-nocheck\n\nimport ClarinetParser, {ClarinetParserOptions} from '../clarinet/clarinet';\nimport JSONPath from '../jsonpath/jsonpath';\n\n// JSONParser builds a JSON object using the events emitted by the Clarinet parser\n\nexport default class JSONParser {\n  readonly parser: ClarinetParser;\n  result = undefined;\n  previousStates = [];\n  currentState = Object.freeze({container: [], key: null});\n  jsonpath: JSONPath = new JSONPath();\n\n  constructor(options: ClarinetParserOptions) {\n    this.reset();\n    this.parser = new ClarinetParser({\n      onready: () => {\n        this.jsonpath = new JSONPath();\n        this.previousStates.length = 0;\n        this.currentState.container.length = 0;\n      },\n\n      onopenobject: (name) => {\n        this._openObject({});\n        if (typeof name !== 'undefined') {\n          this.parser.emit('onkey', name);\n        }\n      },\n\n      onkey: (name) => {\n        this.jsonpath.set(name);\n        this.currentState.key = name;\n      },\n\n      oncloseobject: () => {\n        this._closeObject();\n      },\n\n      onopenarray: () => {\n        this._openArray();\n      },\n\n      onclosearray: () => {\n        this._closeArray();\n      },\n\n      onvalue: (value) => {\n        this._pushOrSet(value);\n      },\n\n      onerror: (error) => {\n        throw error;\n      },\n\n      onend: () => {\n        this.result = this.currentState.container.pop();\n      },\n\n      ...options\n    });\n  }\n\n  reset(): void {\n    this.result = undefined;\n    this.previousStates = [];\n    this.currentState = Object.freeze({container: [], key: null});\n    this.jsonpath = new JSONPath();\n  }\n\n  write(chunk): void {\n    this.parser.write(chunk);\n  }\n\n  close(): void {\n    this.parser.close();\n  }\n\n  // PRIVATE METHODS\n\n  _pushOrSet(value): void {\n    const {container, key} = this.currentState;\n    if (key !== null) {\n      container[key] = value;\n      this.currentState.key = null;\n    } else {\n      container.push(value);\n    }\n  }\n\n  _openArray(newContainer = []): void {\n    this.jsonpath.push(null);\n    this._pushOrSet(newContainer);\n    this.previousStates.push(this.currentState);\n    this.currentState = {container: newContainer, isArray: true, key: null};\n  }\n\n  _closeArray(): void {\n    this.jsonpath.pop();\n    this.currentState = this.previousStates.pop();\n  }\n\n  _openObject(newContainer = {}): void {\n    this.jsonpath.push(null);\n    this._pushOrSet(newContainer);\n    this.previousStates.push(this.currentState);\n    this.currentState = {container: newContainer, isArray: false, key: null};\n  }\n\n  _closeObject(): void {\n    this.jsonpath.pop();\n    this.currentState = this.previousStates.pop();\n  }\n}\n"],"file":"json-parser.js"}

package/dist/es5/lib/parser/streaming-json-parser.js

@@ -0,0 +1,102 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _jsonParser = _interopRequireDefault(require("./json-parser"));
+
+var _jsonpath = _interopRequireDefault(require("../jsonpath/jsonpath"));
+
+class StreamingJSONParser extends _jsonParser.default {
+  constructor(options = {}) {
+    super({
+      onopenarray: () => {
+        if (!this.streamingArray) {
+          if (this._matchJSONPath()) {
+            this.streamingJsonPath = this.getJsonPath().clone();
+            this.streamingArray = [];
+
+            this._openArray(this.streamingArray);
+
+            return;
+          }
+        }
+
+        this._openArray();
+      },
+      onopenobject: name => {
+        if (!this.topLevelObject) {
+          this.topLevelObject = {};
+
+          this._openObject(this.topLevelObject);
+        } else {
+          this._openObject({});
+        }
+
+        if (typeof name !== 'undefined') {
+          this.parser.emit('onkey', name);
+        }
+      }
+    });
+    (0, _defineProperty2.default)(this, "jsonPaths", void 0);
+    (0, _defineProperty2.default)(this, "streamingJsonPath", null);
+    (0, _defineProperty2.default)(this, "streamingArray", null);
+    (0, _defineProperty2.default)(this, "topLevelObject", null);
+    const jsonpaths = options.jsonpaths || [];
+    this.jsonPaths = jsonpaths.map(jsonpath => new _jsonpath.default(jsonpath));
+  }
+
+  write(chunk) {
+    super.write(chunk);
+    let array = [];
+
+    if (this.streamingArray) {
+      array = [...this.streamingArray];
+      this.streamingArray.length = 0;
+    }
+
+    return array;
+  }
+
+  getPartialResult() {
+    return this.topLevelObject;
+  }
+
+  getStreamingJsonPath() {
+    return this.streamingJsonPath;
+  }
+
+  getStreamingJsonPathAsString() {
+    return this.streamingJsonPath && this.streamingJsonPath.toString();
+  }
+
+  getJsonPath() {
+    return this.jsonpath;
+  }
+
+  _matchJSONPath() {
+    const currentPath = this.getJsonPath();
+
+    if (this.jsonPaths.length === 0) {
+      return true;
+    }
+
+    for (const jsonPath of this.jsonPaths) {
+      if (jsonPath.equals(currentPath)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+}
+
+exports.default = StreamingJSONParser;
+//# sourceMappingURL=streaming-json-parser.js.map

package/dist/es5/lib/parser/streaming-json-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/parser/streaming-json-parser.ts"],"names":["StreamingJSONParser","JSONParser","constructor","options","onopenarray","streamingArray","_matchJSONPath","streamingJsonPath","getJsonPath","clone","_openArray","onopenobject","name","topLevelObject","_openObject","parser","emit","jsonpaths","jsonPaths","map","jsonpath","JSONPath","write","chunk","array","length","getPartialResult","getStreamingJsonPath","getStreamingJsonPathAsString","toString","currentPath","jsonPath","equals"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AAMe,MAAMA,mBAAN,SAAkCC,mBAAlC,CAA6C;AAM1DC,EAAAA,WAAW,CAACC,OAA6B,GAAG,EAAjC,EAAqC;AAC9C,UAAM;AACJC,MAAAA,WAAW,EAAE,MAAM;AACjB,YAAI,CAAC,KAAKC,cAAV,EAA0B;AACxB,cAAI,KAAKC,cAAL,EAAJ,EAA2B;AAEzB,iBAAKC,iBAAL,GAAyB,KAAKC,WAAL,GAAmBC,KAAnB,EAAzB;AACA,iBAAKJ,cAAL,GAAsB,EAAtB;;AACA,iBAAKK,UAAL,CAAgB,KAAKL,cAArB;;AACA;AACD;AACF;;AAED,aAAKK,UAAL;AACD,OAbG;AAgBJC,MAAAA,YAAY,EAAGC,IAAD,IAAU;AACtB,YAAI,CAAC,KAAKC,cAAV,EAA0B;AACxB,eAAKA,cAAL,GAAsB,EAAtB;;AACA,eAAKC,WAAL,CAAiB,KAAKD,cAAtB;AACD,SAHD,MAGO;AACL,eAAKC,WAAL,CAAiB,EAAjB;AACD;;AACD,YAAI,OAAOF,IAAP,KAAgB,WAApB,EAAiC;AAC/B,eAAKG,MAAL,CAAYC,IAAZ,CAAiB,OAAjB,EAA0BJ,IAA1B;AACD;AACF;AA1BG,KAAN;AAD8C;AAAA,6DAJH,IAIG;AAAA,0DAHT,IAGS;AAAA,0DAFR,IAEQ;AA6B9C,UAAMK,SAAS,GAAGd,OAAO,CAACc,SAAR,IAAqB,EAAvC;AACA,SAAKC,SAAL,GAAiBD,SAAS,CAACE,GAAV,CAAeC,QAAD,IAAc,IAAIC,iBAAJ,CAAaD,QAAb,CAA5B,CAAjB;AACD;;AASDE,EAAAA,KAAK,CAACC,KAAD,EAAQ;AACX,UAAMD,KAAN,CAAYC,KAAZ;AACA,QAAIC,KAAY,GAAG,EAAnB;;AACA,QAAI,KAAKnB,cAAT,EAAyB;AACvBmB,MAAAA,KAAK,GAAG,CAAC,GAAG,KAAKnB,cAAT,CAAR;AACA,WAAKA,cAAL,CAAoBoB,MAApB,GAA6B,CAA7B;AACD;;AACD,WAAOD,KAAP;AACD;;AAODE,EAAAA,gBAAgB,GAAG;AACjB,WAAO,KAAKb,cAAZ;AACD;;AAEDc,EAAAA,oBAAoB,GAAG;AACrB,WAAO,KAAKpB,iBAAZ;AACD;;AAEDqB,EAAAA,4BAA4B,GAAG;AAC7B,WAAO,KAAKrB,iBAAL,IAA0B,KAAKA,iBAAL,CAAuBsB,QAAvB,EAAjC;AACD;;AAEDrB,EAAAA,WAAW,GAAG;AACZ,WAAO,KAAKY,QAAZ;AACD;;AAODd,EAAAA,cAAc,GAAG;AACf,UAAMwB,WAAW,GAAG,KAAKtB,WAAL,EAApB;;AAKA,QAAI,KAAKU,SAAL,CAAeO,MAAf,KAA0B,CAA9B,EAAiC;AAC/B,aAAO,IAAP;AACD;;AAED,SAAK,MAAMM,QAAX,IAAuB,KAAKb,SAA5B,EAAuC;AACrC,UAAIa,QAAQ,CAACC,MAAT,CAAgBF,WAAhB,CAAJ,EAAkC;AAChC,eAAO,IAAP;AACD;AACF;;AAED,WAAO,KAAP;AACD;;AAnGyD","sourcesContent":["import {default as JSONParser} from './json-parser';\nimport JSONPath from '../jsonpath/jsonpath';\n\n/**\n * The `StreamingJSONParser` looks for the first array in the JSON structure.\n * and emits an array of chunks\n */\nexport default class StreamingJSONParser extends JSONParser {\n  private jsonPaths: JSONPath[];\n  private streamingJsonPath: JSONPath | null = null;\n  private streamingArray: any[] | null = null;\n  private topLevelObject: object | null = null;\n\n  constructor(options: {[key: string]: any} = {}) {\n    super({\n      onopenarray: () => {\n        if (!this.streamingArray) {\n          if (this._matchJSONPath()) {\n            // @ts-ignore\n            this.streamingJsonPath = this.getJsonPath().clone();\n            this.streamingArray = [];\n            this._openArray(this.streamingArray as []);\n            return;\n          }\n        }\n\n        this._openArray();\n      },\n\n      // Redefine onopenarray to inject value for top-level object\n      onopenobject: (name) => {\n        if (!this.topLevelObject) {\n          this.topLevelObject = {};\n          this._openObject(this.topLevelObject);\n        } else {\n          this._openObject({});\n        }\n        if (typeof name !== 'undefined') {\n          this.parser.emit('onkey', name);\n        }\n      }\n    });\n    const jsonpaths = options.jsonpaths || [];\n    this.jsonPaths = jsonpaths.map((jsonpath) => new JSONPath(jsonpath));\n  }\n\n  /**\n   * write REDEFINITION\n   * - super.write() chunk to parser\n   * - get the contents (so far) of \"topmost-level\" array as batch of rows\n   * - clear top-level array\n   * - return the batch of rows\\\n   */\n  write(chunk) {\n    super.write(chunk);\n    let array: any[] = [];\n    if (this.streamingArray) {\n      array = [...this.streamingArray];\n      this.streamingArray.length = 0;\n    }\n    return array;\n  }\n\n  /**\n   * Returns a partially formed result object\n   * Useful for returning the \"wrapper\" object when array is not top level\n   * e.g. GeoJSON\n   */\n  getPartialResult() {\n    return this.topLevelObject;\n  }\n\n  getStreamingJsonPath() {\n    return this.streamingJsonPath;\n  }\n\n  getStreamingJsonPathAsString() {\n    return this.streamingJsonPath && this.streamingJsonPath.toString();\n  }\n\n  getJsonPath() {\n    return this.jsonpath;\n  }\n\n  // PRIVATE METHODS\n\n  /**\n   * Checks is this.getJsonPath matches the jsonpaths provided in options\n   */\n  _matchJSONPath() {\n    const currentPath = this.getJsonPath();\n    // console.debug(`Testing JSONPath`, currentPath);\n\n    // Backwards compatibility, match any array\n    // TODO implement using wildcard once that is supported\n    if (this.jsonPaths.length === 0) {\n      return true;\n    }\n\n    for (const jsonPath of this.jsonPaths) {\n      if (jsonPath.equals(currentPath)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n}\n"],"file":"streaming-json-parser.js"}

package/dist/es5/ndjson-loader.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._typecheckNDJSONLoader = exports.NDJSONLoader = void 0;
+
+var _parseNdjson = _interopRequireDefault(require("./lib/parse-ndjson"));
+
+var _parseNdjsonInBatches = _interopRequireDefault(require("./lib/parse-ndjson-in-batches"));
+
+const VERSION = typeof "3.1.0-beta.2" !== 'undefined' ? "3.1.0-beta.2" : 'latest';
+const NDJSONLoader = {
+  name: 'NDJSON',
+  id: 'ndjson',
+  module: 'json',
+  version: VERSION,
+  extensions: ['ndjson'],
+  mimeTypes: ['application/x-ndjson'],
+  category: 'table',
+  text: true,
+  parse,
+  parseTextSync,
+  parseInBatches,
+  options: {}
+};
+exports.NDJSONLoader = NDJSONLoader;
+
+async function parse(arrayBuffer) {
+  return parseTextSync(new TextDecoder().decode(arrayBuffer));
+}
+
+function parseTextSync(text) {
+  return (0, _parseNdjson.default)(text);
+}
+
+function parseInBatches(asyncIterator, options) {
+  return (0, _parseNdjsonInBatches.default)(asyncIterator, options);
+}
+
+const _typecheckNDJSONLoader = NDJSONLoader;
+exports._typecheckNDJSONLoader = _typecheckNDJSONLoader;
+//# sourceMappingURL=ndjson-loader.js.map

package/dist/es5/ndjson-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ndjson-loader.ts"],"names":["VERSION","NDJSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parse","parseTextSync","parseInBatches","options","arrayBuffer","TextDecoder","decode","asyncIterator","_typecheckNDJSONLoader"],"mappings":";;;;;;;;;AAEA;;AACA;;AAIA,MAAMA,OAAO,GAAG,0BAAuB,WAAvB,oBAAmD,QAAnE;AAEO,MAAMC,YAAY,GAAG;AAC1BC,EAAAA,IAAI,EAAE,QADoB;AAE1BC,EAAAA,EAAE,EAAE,QAFsB;AAG1BC,EAAAA,MAAM,EAAE,MAHkB;AAI1BC,EAAAA,OAAO,EAAEL,OAJiB;AAK1BM,EAAAA,UAAU,EAAE,CAAC,QAAD,CALc;AAM1BC,EAAAA,SAAS,EAAE,CAAC,sBAAD,CANe;AAO1BC,EAAAA,QAAQ,EAAE,OAPgB;AAQ1BC,EAAAA,IAAI,EAAE,IARoB;AAS1BC,EAAAA,KAT0B;AAU1BC,EAAAA,aAV0B;AAW1BC,EAAAA,cAX0B;AAY1BC,EAAAA,OAAO,EAAE;AAZiB,CAArB;;;AAeP,eAAeH,KAAf,CAAqBI,WAArB,EAA+C;AAC7C,SAAOH,aAAa,CAAC,IAAII,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,CAApB;AACD;;AAED,SAASH,aAAT,CAAuBF,IAAvB,EAAqC;AACnC,SAAO,0BAAgBA,IAAhB,CAAP;AACD;;AAED,SAASG,cAAT,CACEK,aADF,EAEEJ,OAFF,EAGwB;AACtB,SAAO,mCAAqBI,aAArB,EAAoCJ,OAApC,CAAP;AACD;;AAEM,MAAMK,sBAAwC,GAAGjB,YAAjD","sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport parseNDJSONSync from './lib/parse-ndjson';\nimport parseNDJSONInBatches from './lib/parse-ndjson-in-batches';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport const NDJSONLoader = {\n  name: 'NDJSON',\n  id: 'ndjson',\n  module: 'json',\n  version: VERSION,\n  extensions: ['ndjson'],\n  mimeTypes: ['application/x-ndjson'],\n  category: 'table',\n  text: true,\n  parse,\n  parseTextSync,\n  parseInBatches,\n  options: {}\n};\n\nasync function parse(arrayBuffer: ArrayBuffer) {\n  return parseTextSync(new TextDecoder().decode(arrayBuffer));\n}\n\nfunction parseTextSync(text: string) {\n  return parseNDJSONSync(text);\n}\n\nfunction parseInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options?: LoaderOptions\n): AsyncIterable<Batch> {\n  return parseNDJSONInBatches(asyncIterator, options);\n}\n\nexport const _typecheckNDJSONLoader: LoaderWithParser = NDJSONLoader;\n"],"file":"ndjson-loader.js"}

package/dist/es5/workers/geojson-worker.js

@@ -0,0 +1,8 @@
+"use strict";
+
+var _loaderUtils = require("@loaders.gl/loader-utils");
+
+var _geojsonLoader = require("../geojson-loader");
+
+(0, _loaderUtils.createLoaderWorker)(_geojsonLoader.GeoJSONLoader);
+//# sourceMappingURL=geojson-worker.js.map

package/dist/es5/workers/geojson-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/workers/geojson-worker.ts"],"names":["GeoJSONLoader"],"mappings":";;AAAA;;AACA;;AAEA,qCAAmBA,4BAAnB","sourcesContent":["import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {GeoJSONLoader} from '../geojson-loader';\n\ncreateLoaderWorker(GeoJSONLoader);\n"],"file":"geojson-worker.js"}

package/dist/esm/bundle.js

@@ -0,0 +1,5 @@
+const moduleExports = require('./index');
+
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/esm/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}