@loaders.gl/core 4.0.0-alpha.5 → 4.0.0-alpha.6

package/src/lib/utils/response-utils.ts

@@ -65,7 +65,7 @@ export async function checkResponse(response: Response): Promise<void> {
 export function checkResponseSync(response: Response): void {
   if (!response.ok) {
     let message = `${response.status} ${response.statusText}`;
-    message = message.length > 60 ? `${message.slice(60)}...` : message;
+    message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
     throw new Error(message);
   }
 }
@@ -81,7 +81,7 @@ async function getResponseError(response): Promise<string> {
       text += ` ${await response.text()}`;
     }
     message += text;
-    message = message.length > 60 ? `${message.slice(60)}...` : message;
+    message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
   } catch (error) {
     // eslint forbids return in a finally statement, so we just catch here
   }

package/src/null-loader.ts

@@ -21,6 +21,16 @@ export const NullWorkerLoader: Loader = {
   }
 };
 
+/**
+ * Returns arguments passed to the parse API in a format that can be transfered to a
+ * web worker. The `context` parameter is stripped using JSON.stringify & parse.
+ */
+function parseSync(arrayBuffer, options, context) {
+  if (!options.null.echoParameters) return null;
+  context = context && JSON.parse(JSON.stringify(context));
+  return {arrayBuffer, options, context};
+}
+
 /**
  * Loads any data and returns null (or optionally passes through data unparsed)
  */
@@ -31,15 +41,17 @@ export const NullLoader: LoaderWithParser = {
   version: VERSION,
   mimeTypes: ['application/x.empty'],
   extensions: ['null'],
-  parse: async (arrayBuffer) => arrayBuffer,
-  parseSync: (arrayBuffer) => arrayBuffer,
-  parseInBatches: async function* generator(asyncIterator) {
+  parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options, context),
+  parseSync,
+  parseInBatches: async function* generator(asyncIterator, options, context) {
     for await (const batch of asyncIterator) {
-      yield batch;
+      yield parseSync(batch, options, context);
     }
   },
   tests: [() => false],
   options: {
-    null: {}
+    null: {
+      echoParameters: false
+    }
   }
 };

package/dist/bundle.js.map

@@ -1 +0,0 @@
-{"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"}

package/dist/core-addons/write-file-browser.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"write-file-browser.js"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"names":["fetchFile","readArrayBuffer","readFileSync","writeFile","writeFileSync","setLoaderOptions","registerLoaders","selectLoader","selectLoaderSync","parse","parseSync","parseInBatches","load","loadInBatches","encode","encodeSync","encodeInBatches","encodeText","encodeURLtoURL","save","saveSync","setPathPrefix","getPathPrefix","resolvePath","RequestScheduler","makeIterator","makeStream","NullWorkerLoader","NullLoader","JSONLoader","default","_fetchProgress","_BrowserFileSystem","_unregisterLoaders","isBrowser","isWorker","self","window","global","document","assert","forEach","concatenateArrayBuffersAsync","makeTextDecoderIterator","makeTextEncoderIterator","makeLineIterator","makeNumberedLineIterator","isPureObject","isPromise","isIterable","isAsyncIterable","isIterator","isResponse","isReadableStream","isWritableStream"],"mappings":"AACA,SAAQA,SAAR,QAAwB,wBAAxB;AAEA,SAAQC,eAAR,QAA8B,+BAA9B;AACA,SAAQC,YAAR,QAA2B,uBAA3B;AACA,SAAQC,SAAR,EAAmBC,aAAnB,QAAuC,wBAAvC;AAGA,SAAQC,gBAAR,QAA+B,8BAA/B;AACA,SAAQC,eAAR,QAA8B,4BAA9B;AACA,SAAQC,YAAR,EAAsBC,gBAAtB,QAA6C,yBAA7C;AAGA,SAAQC,KAAR,QAAoB,iBAApB;AACA,SAAQC,SAAR,QAAwB,sBAAxB;AACA,SAAQC,cAAR,QAA6B,4BAA7B;AAEA,SAAQC,IAAR,QAAmB,gBAAnB;AACA,SAAQC,aAAR,QAA4B,2BAA5B;AAGA,SAAQC,MAAR,EAAgBC,UAAhB,EAA4BC,eAA5B,EAA6CC,UAA7C,EAAyDC,cAAzD,QAA8E,kBAA9E;AACA,SAAQC,IAAR,EAAcC,QAAd,QAA6B,gBAA7B;AAGA,SAAQC,aAAR,EAAuBC,aAAvB,EAAsCC,WAAtC,QAAwD,0BAAxD;AACA,SAAQC,gBAAR,QAA+B,0BAA/B;AAGA,SAAQC,YAAR,QAA2B,yCAA3B;AACA,SAAQC,UAAR,QAAyB,0CAAzB;AAGA,SAAQC,gBAAR,EAA0BC,UAA1B,QAA2C,eAA3C;AACA,SAAQC,UAAR,QAAyB,0BAAzB;AAGA,SAAQC,OAAO,IAAIC,cAAnB,QAAwC,+BAAxC;AACA,SAAQD,OAAO,IAAIE,kBAAnB,QAA4C,sCAA5C;AAGA,SAAQC,kBAAR,QAAiC,4BAAjC;AAMA,SAAQC,SAAR,EAAmBC,QAAnB,EAA6BC,IAA7B,EAAmCC,MAAnC,EAA2CC,MAA3C,EAAmDC,QAAnD,QAAkE,0BAAlE;AACA,SAAQC,MAAR,QAAqB,0BAArB;AACA,SAAQC,OAAR,EAAiBC,4BAAjB,QAAoD,0BAApD;AAEA,SACEC,uBADF,EAEEC,uBAFF,EAGEC,gBAHF,EAIEC,wBAJF,QAKO,0BALP;AAQA,SACEC,YADF,EAEEC,SAFF,EAGEC,UAHF,EAIEC,eAJF,EAKEC,UALF,EAMEC,UANF,EAOEC,gBAPF,EAQEC,gBARF,QASO,4BATP","sourcesContent":["// FILE READING AND WRITING\nexport {fetchFile} from './lib/fetch/fetch-file';\n\nexport {readArrayBuffer} from './lib/fetch/read-array-buffer';\nexport {readFileSync} from './lib/fetch/read-file';\nexport {writeFile, writeFileSync} from './lib/fetch/write-file';\n\n// CONFIGURATION\nexport {setLoaderOptions} from './lib/api/set-loader-options';\nexport {registerLoaders} from './lib/api/register-loaders';\nexport {selectLoader, selectLoaderSync} from './lib/api/select-loader';\n\n// LOADING (READING + PARSING)\nexport {parse} from './lib/api/parse';\nexport {parseSync} from './lib/api/parse-sync';\nexport {parseInBatches} from './lib/api/parse-in-batches';\n\nexport {load} from './lib/api/load';\nexport {loadInBatches} from './lib/api/load-in-batches';\n\n// ENCODING (ENCODING AND WRITING)\nexport {encode, encodeSync, encodeInBatches, encodeText, encodeURLtoURL} from './lib/api/encode';\nexport {save, saveSync} from './lib/api/save';\n\n// CORE UTILS SHARED WITH LOADERS (RE-EXPORTED FROM LOADER-UTILS)\nexport {setPathPrefix, getPathPrefix, resolvePath} from '@loaders.gl/loader-utils';\nexport {RequestScheduler} from '@loaders.gl/loader-utils';\n\n// ITERATOR UTILS\nexport {makeIterator} from './iterators/make-iterator/make-iterator';\nexport {makeStream} from './iterators/make-stream/make-node-stream';\n\n// CORE LOADERS\nexport {NullWorkerLoader, NullLoader} from './null-loader';\nexport {JSONLoader} from '@loaders.gl/loader-utils';\n\n// EXPERIMENTAL\nexport {default as _fetchProgress} from './lib/progress/fetch-progress';\nexport {default as _BrowserFileSystem} from './lib/filesystems/browser-filesystem';\n\n// FOR TESTING\nexport {_unregisterLoaders} from './lib/api/register-loaders';\n\n//\n// TODO - MOVE TO LOADER-UTILS AND DEPRECATE IN CORE?\n//\n\nexport {isBrowser, isWorker, self, window, global, document} from '@loaders.gl/loader-utils';\nexport {assert} from '@loaders.gl/loader-utils';\nexport {forEach, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\nexport {\n  makeTextDecoderIterator,\n  makeTextEncoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from '@loaders.gl/loader-utils';\n\n// \"JAVASCRIPT\" UTILS - move to loader-utils?\nexport {\n  isPureObject,\n  isPromise,\n  isIterable,\n  isAsyncIterable,\n  isIterator,\n  isResponse,\n  isReadableStream,\n  isWritableStream\n} from './javascript-utils/is-type';\n"],"file":"index.js"}

package/dist/iterators/batch-iterators/timed-batch-iterator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/iterators/batch-iterators/timed-batch-iterator.ts"],"names":["timedBatchIterator","batchIterator","timeout","start","Date","now","batches","batch","push"],"mappings":"AAGA,OAAO,gBAAgBA,kBAAhB,CAA0CC,aAA1C,EAA+EC,OAA/E,EAAwF;AAC7F,MAAIC,KAAK,GAAGC,IAAI,CAACC,GAAL,EAAZ;AACA,MAAIC,OAAgB,GAAG,EAAvB;;AACA,aAAW,MAAMC,KAAjB,IAA0BN,aAA1B,EAAyC;AACvCK,IAAAA,OAAO,CAACE,IAAR,CAAaD,KAAb;;AACA,QAAIH,IAAI,CAACC,GAAL,KAAaF,KAAb,GAAqBD,OAAzB,EAAkC;AAChC,YAAMI,OAAN;AACAH,MAAAA,KAAK,GAAGC,IAAI,CAACC,GAAL,EAAR;AACAC,MAAAA,OAAO,GAAG,EAAV;AACD;AACF;;AAED,MAAIA,OAAJ,EAAa;AACX,UAAMA,OAAN;AACD;AACF","sourcesContent":["/**\n * \"Debounces\" batches and returns them in groups\n */\nexport async function* timedBatchIterator<Batch>(batchIterator: AsyncIterable<Batch>, timeout) {\n  let start = Date.now();\n  let batches: Batch[] = [];\n  for await (const batch of batchIterator) {\n    batches.push(batch);\n    if (Date.now() - start > timeout) {\n      yield batches;\n      start = Date.now();\n      batches = [];\n    }\n  }\n\n  if (batches) {\n    yield batches;\n  }\n}\n"],"file":"timed-batch-iterator.js"}

package/dist/iterators/make-iterator/make-array-buffer-iterator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/iterators/make-iterator/make-array-buffer-iterator.ts"],"names":["DEFAULT_CHUNK_SIZE","makeArrayBufferIterator","arrayBuffer","options","chunkSize","byteOffset","byteLength","chunkByteLength","Math","min","chunk","ArrayBuffer","sourceArray","Uint8Array","chunkArray","set"],"mappings":"AAEA,MAAMA,kBAAkB,GAAG,MAAM,IAAjC;AAQA,OAAO,UAAUC,uBAAV,CACLC,WADK,EAELC,OAAwB,GAAG,EAFtB,EAGkB;AACvB,QAAM;AAACC,IAAAA,SAAS,GAAGJ;AAAb,MAAmCG,OAAzC;AAEA,MAAIE,UAAU,GAAG,CAAjB;;AAEA,SAAOA,UAAU,GAAGH,WAAW,CAACI,UAAhC,EAA4C;AAE1C,UAAMC,eAAe,GAAGC,IAAI,CAACC,GAAL,CAASP,WAAW,CAACI,UAAZ,GAAyBD,UAAlC,EAA8CD,SAA9C,CAAxB;AACA,UAAMM,KAAK,GAAG,IAAIC,WAAJ,CAAgBJ,eAAhB,CAAd;AAGA,UAAMK,WAAW,GAAG,IAAIC,UAAJ,CAAeX,WAAf,EAA4BG,UAA5B,EAAwCE,eAAxC,CAApB;AACA,UAAMO,UAAU,GAAG,IAAID,UAAJ,CAAeH,KAAf,CAAnB;AACAI,IAAAA,UAAU,CAACC,GAAX,CAAeH,WAAf;AAGAP,IAAAA,UAAU,IAAIE,eAAd;AACA,UAAMG,KAAN;AACD;AACF","sourcesContent":["import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 256 * 1024;\n\n/**\n * Returns an iterator that breaks a big ArrayBuffer into chunks and yields them one-by-one\n * @param blob ArrayBuffer to iterate over\n * @param options\n * @param options.chunkSize\n */\nexport function* makeArrayBufferIterator(\n  arrayBuffer: ArrayBuffer,\n  options: IteratorOptions = {}\n): Iterable<ArrayBuffer> {\n  const {chunkSize = DEFAULT_CHUNK_SIZE} = options;\n\n  let byteOffset = 0;\n\n  while (byteOffset < arrayBuffer.byteLength) {\n    // Create a chunk of the right size\n    const chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);\n    const chunk = new ArrayBuffer(chunkByteLength);\n\n    // Copy data from the big chunk\n    const sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);\n    const chunkArray = new Uint8Array(chunk);\n    chunkArray.set(sourceArray);\n\n    // yield the chunk\n    byteOffset += chunkByteLength;\n    yield chunk;\n  }\n}\n"],"file":"make-array-buffer-iterator.js"}

package/dist/iterators/make-iterator/make-blob-iterator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/iterators/make-iterator/make-blob-iterator.ts"],"names":["DEFAULT_CHUNK_SIZE","makeBlobIterator","blob","options","chunkSize","offset","size","end","chunk","slice","arrayBuffer"],"mappings":"AAEA,MAAMA,kBAAkB,GAAG,OAAO,IAAlC;AAQA,OAAO,gBAAgBC,gBAAhB,CACLC,IADK,EAELC,OAFK,EAGuB;AAC5B,QAAMC,SAAS,GAAG,CAAAD,OAAO,SAAP,IAAAA,OAAO,WAAP,YAAAA,OAAO,CAAEC,SAAT,KAAsBJ,kBAAxC;AAEA,MAAIK,MAAM,GAAG,CAAb;;AACA,SAAOA,MAAM,GAAGH,IAAI,CAACI,IAArB,EAA2B;AACzB,UAAMC,GAAG,GAAGF,MAAM,GAAGD,SAArB;AAEA,UAAMI,KAAK,GAAG,MAAMN,IAAI,CAACO,KAAL,CAAWJ,MAAX,EAAmBE,GAAnB,EAAwBG,WAAxB,EAApB;AAEAL,IAAAA,MAAM,GAAGE,GAAT;AACA,UAAMC,KAAN;AACD;AACF","sourcesContent":["import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 1024 * 1024; // 1MB — biggest value that keeps UI responsive\n\n/**\n * Returns an iterator that breaks a big Blob into chunks and yields them one-by-one\n * @param blob Blob or File object\n * @param options\n * @param options.chunkSize\n */\nexport async function* makeBlobIterator(\n  blob: Blob,\n  options?: IteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;\n\n  let offset = 0;\n  while (offset < blob.size) {\n    const end = offset + chunkSize;\n\n    const chunk = await blob.slice(offset, end).arrayBuffer();\n\n    offset = end;\n    yield chunk;\n  }\n}\n"],"file":"make-blob-iterator.js"}

package/dist/iterators/make-iterator/make-iterator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/iterators/make-iterator/make-iterator.ts"],"names":["makeStringIterator","makeArrayBufferIterator","makeBlobIterator","makeStreamIterator","isBlob","isReadableStream","isResponse","makeIterator","data","options","ArrayBuffer","response","body","Error"],"mappings":"AAEA,SAAQA,kBAAR,QAAiC,wBAAjC;AACA,SAAQC,uBAAR,QAAsC,8BAAtC;AACA,SAAQC,gBAAR,QAA+B,sBAA/B;AAEA,SAAQC,kBAAR,QAAiC,wBAAjC;AACA,SAAQC,MAAR,EAAgBC,gBAAhB,EAAkCC,UAAlC,QAAmD,gCAAnD;AAiBA,OAAO,SAASC,YAAT,CACLC,IADK,EAELC,OAFK,EAG+C;AACpD,MAAI,OAAOD,IAAP,KAAgB,QAApB,EAA8B;AAE5B,WAAOR,kBAAkB,CAACQ,IAAD,EAAOC,OAAP,CAAzB;AACD;;AACD,MAAID,IAAI,YAAYE,WAApB,EAAiC;AAC/B,WAAOT,uBAAuB,CAACO,IAAD,EAAOC,OAAP,CAA9B;AACD;;AACD,MAAIL,MAAM,CAACI,IAAD,CAAV,EAAkB;AAChB,WAAON,gBAAgB,CAACM,IAAD,EAAeC,OAAf,CAAvB;AACD;;AACD,MAAIJ,gBAAgB,CAACG,IAAD,CAApB,EAA4B;AAC1B,WAAOL,kBAAkB,CAACK,IAAD,EAAyBC,OAAzB,CAAzB;AACD;;AACD,MAAIH,UAAU,CAACE,IAAD,CAAd,EAAsB;AACpB,UAAMG,QAAQ,GAAGH,IAAjB;AACA,WAAOL,kBAAkB,CAACQ,QAAQ,CAACC,IAAV,EAAkCH,OAAlC,CAAzB;AACD;;AACD,QAAM,IAAII,KAAJ,CAAU,cAAV,CAAN;AACD","sourcesContent":["import type {ReadStream} from 'fs';\n\nimport {makeStringIterator} from './make-string-iterator';\nimport {makeArrayBufferIterator} from './make-array-buffer-iterator';\nimport {makeBlobIterator} from './make-blob-iterator';\nimport type {StreamIteratorOptions} from './make-stream-iterator';\nimport {makeStreamIterator} from './make-stream-iterator';\nimport {isBlob, isReadableStream, isResponse} from '../../javascript-utils/is-type';\n\n/**\n * @param [options.chunkSize]\n */\nexport type IteratorOptions = StreamIteratorOptions & {\n  chunkSize?: number;\n};\n\n/**\n * Returns an iterator that breaks its input into chunks and yields them one-by-one.\n * @param data\n * @param options\n * @returns\n * This function can e.g. be used to enable data sources that can only be read atomically\n * (such as `Blob` and `File` via `FileReader`) to still be parsed in batches.\n */\nexport function makeIterator(\n  data: ArrayBuffer | string | Blob | Response | ReadableStream | ReadStream,\n  options?: IteratorOptions\n): AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer> {\n  if (typeof data === 'string') {\n    // Note: Converts string chunks to binary\n    return makeStringIterator(data, options);\n  }\n  if (data instanceof ArrayBuffer) {\n    return makeArrayBufferIterator(data, options);\n  }\n  if (isBlob(data)) {\n    return makeBlobIterator(data as Blob, options);\n  }\n  if (isReadableStream(data)) {\n    return makeStreamIterator(data as ReadableStream, options);\n  }\n  if (isResponse(data)) {\n    const response = data as Response;\n    return makeStreamIterator(response.body as ReadableStream, options);\n  }\n  throw new Error('makeIterator');\n}\n"],"file":"make-iterator.js"}

package/dist/iterators/make-iterator/make-stream-iterator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/iterators/make-iterator/make-stream-iterator.ts"],"names":["isBrowser","toArrayBuffer","makeStreamIterator","stream","options","makeBrowserStreamIterator","makeNodeStreamIterator","reader","getReader","nextBatchPromise","currentBatchPromise","read","_streamReadAhead","done","value","error","releaseLock","chunk"],"mappings":"AACA,SAAQA,SAAR,EAAmBC,aAAnB,QAAuC,0BAAvC;AAUA,OAAO,SAASC,kBAAT,CACLC,MADK,EAELC,OAFK,EAGuB;AAC5B,SAAOJ,SAAS,GACZK,yBAAyB,CAACF,MAAD,EAA2BC,OAA3B,CADb,GAEZE,sBAAsB,CAACH,MAAD,EAAqBC,OAArB,CAF1B;AAGD;;AAOD,gBAAgBC,yBAAhB,CACEF,MADF,EAEEC,OAFF,EAG8B;AAU5B,QAAMG,MAAM,GAAGJ,MAAM,CAACK,SAAP,EAAf;AAEA,MAAIC,gBAAJ;;AAEA,MAAI;AAEF,WAAO,IAAP,EAAa;AACX,YAAMC,mBAAmB,GAAGD,gBAAgB,IAAIF,MAAM,CAACI,IAAP,EAAhD;;AAGA,UAAIP,OAAJ,aAAIA,OAAJ,eAAIA,OAAO,CAAEQ,gBAAb,EAA+B;AAC7BH,QAAAA,gBAAgB,GAAGF,MAAM,CAACI,IAAP,EAAnB;AACD;;AAGD,YAAM;AAACE,QAAAA,IAAD;AAAOC,QAAAA;AAAP,UAAgB,MAAMJ,mBAA5B;;AAEA,UAAIG,IAAJ,EAAU;AACR;AACD;;AAED,YAAMZ,aAAa,CAACa,KAAD,CAAnB;AACD;AACF,GAnBD,CAmBE,OAAOC,KAAP,EAAc;AAGdR,IAAAA,MAAM,CAACS,WAAP;AACD;AACF;;AAOD,gBAAgBV,sBAAhB,CACEH,MADF,EAEEC,OAFF,EAG8B;AAG5B,aAAW,MAAMa,KAAjB,IAA0Bd,MAA1B,EAAkC;AAChC,UAAMF,aAAa,CAACgB,KAAD,CAAnB;AACD;AACF","sourcesContent":["import type {Readable} from 'stream';\nimport {isBrowser, toArrayBuffer} from '@loaders.gl/loader-utils';\n\nexport type StreamIteratorOptions = {\n  _streamReadAhead?: boolean;\n};\n\n/**\n * Returns an async iterable that reads from a stream (works in both Node.js and browsers)\n * @param stream stream to iterator over\n */\nexport function makeStreamIterator(\n  stream: ReadableStream | Readable,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  return isBrowser\n    ? makeBrowserStreamIterator(stream as ReadableStream, options)\n    : makeNodeStreamIterator(stream as Readable, options);\n}\n\n/**\n * Returns an async iterable that reads from a DOM (browser) stream\n * @param stream stream to iterate from\n * @see https://jakearchibald.com/2017/async-iterators-and-generators/#making-streams-iterate\n */\nasync function* makeBrowserStreamIterator(\n  stream: ReadableStream,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  // WhatWG: stream is supposed to have a `getIterator` method\n  // if (typeof stream.getIterator === 'function') {\n  //   return stream.getIterator();\n  // }\n  // if (typeof stream[Symbol.asyncIterator] === 'function') {\n  //   return makeToArrayBufferIterator(stream);\n  // }\n\n  // In the browser, we first need to get a lock on the stream\n  const reader = stream.getReader();\n\n  let nextBatchPromise: Promise<{done?: boolean; value?: Uint8Array}> | undefined;\n\n  try {\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n      const currentBatchPromise = nextBatchPromise || reader.read();\n      // Issue a read for an additional batch, while we await the next batch\n      // Idea is to make fetching happen in parallel with processing / parsing\n      if (options?._streamReadAhead) {\n        nextBatchPromise = reader.read();\n      }\n      // Read from the stream\n      // value is a Uint8Array\n      const {done, value} = await currentBatchPromise;\n      // Exit if we're done\n      if (done) {\n        return;\n      }\n      // Else yield the chunk\n      yield toArrayBuffer(value);\n    }\n  } catch (error) {\n    // TODO - examples makes it look like this should always be called,\n    // but that generates exceptions so only call it if we do not reach the end\n    reader.releaseLock();\n  }\n}\n\n/**\n * Returns an async iterable that reads from a DOM (browser) stream\n * @param stream stream to iterate from\n * @note Requires Node.js >= 10\n */\nasync function* makeNodeStreamIterator(\n  stream: Readable,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  // Hacky test for node version to ensure we don't call bad polyfills\n  // NODE 10+: stream is an asyncIterator\n  for await (const chunk of stream) {\n    yield toArrayBuffer(chunk); // Coerce each chunk to ArrayBuffer\n  }\n}\n/* TODO - remove NODE < 10\n * @see https://github.com/bustle/streaming-iterables, MIT license\n *\n  if (typeof stream[Symbol.asyncIterator] === 'function') {\n    return;\n  }\n\n  // TODO - check if is this ever used in Node 10+?\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    const data = stream.read();\n    if (data !== null) {\n      yield toArrayBuffer(data);\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n    if (stream._readableState?.ended) {\n      return;\n    }\n    await onceReadable(stream);\n  }\n\nasync function onceReadable(stream: Readable): Promise<any> {\n  return new Promise((resolve) => {\n    stream.once('readable', resolve);\n  });\n}\n  */\n"],"file":"make-stream-iterator.js"}

package/dist/iterators/make-iterator/make-string-iterator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/iterators/make-iterator/make-string-iterator.ts"],"names":["DEFAULT_CHUNK_SIZE","makeStringIterator","string","options","chunkSize","offset","textEncoder","TextEncoder","length","chunkLength","Math","min","chunk","slice","encode"],"mappings":"AAEA,MAAMA,kBAAkB,GAAG,MAAM,IAAjC;AAQA,OAAO,UAAUC,kBAAV,CACLC,MADK,EAELC,OAFK,EAGkB;AACvB,QAAMC,SAAS,GAAG,CAAAD,OAAO,SAAP,IAAAA,OAAO,WAAP,YAAAA,OAAO,CAAEC,SAAT,KAAsBJ,kBAAxC;AAEA,MAAIK,MAAM,GAAG,CAAb;AACA,QAAMC,WAAW,GAAG,IAAIC,WAAJ,EAApB;;AACA,SAAOF,MAAM,GAAGH,MAAM,CAACM,MAAvB,EAA+B;AAE7B,UAAMC,WAAW,GAAGC,IAAI,CAACC,GAAL,CAAST,MAAM,CAACM,MAAP,GAAgBH,MAAzB,EAAiCD,SAAjC,CAApB;AACA,UAAMQ,KAAK,GAAGV,MAAM,CAACW,KAAP,CAAaR,MAAb,EAAqBA,MAAM,GAAGI,WAA9B,CAAd;AACAJ,IAAAA,MAAM,IAAII,WAAV;AAGA,UAAMH,WAAW,CAACQ,MAAZ,CAAmBF,KAAnB,CAAN;AACD;AACF","sourcesContent":["import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 256 * 1024;\n\n/**\n * Returns an iterator that breaks a big string into chunks and yields them one-by-one as ArrayBuffers\n * @param blob string to iterate over\n * @param options\n * @param options.chunkSize\n */\nexport function* makeStringIterator(\n  string: string,\n  options?: IteratorOptions\n): Iterable<ArrayBuffer> {\n  const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;\n\n  let offset = 0;\n  const textEncoder = new TextEncoder();\n  while (offset < string.length) {\n    // Create a chunk of the right size\n    const chunkLength = Math.min(string.length - offset, chunkSize);\n    const chunk = string.slice(offset, offset + chunkLength);\n    offset += chunkLength;\n\n    // yield an ArrayBuffer chunk\n    yield textEncoder.encode(chunk);\n  }\n}\n"],"file":"make-string-iterator.js"}

package/dist/iterators/make-stream/make-dom-stream.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/iterators/make-stream/make-dom-stream.ts"],"names":["makeStream","source","options","iterator","Symbol","asyncIterator","ReadableStream","type","pull","controller","done","value","next","close","enqueue","Uint8Array","error","cancel","return","highWaterMark"],"mappings":"AAaA,OAAO,SAASA,UAAT,CACLC,MADK,EAELC,OAFK,EAGW;AAChB,QAAMC,QAAQ,GAAGF,MAAM,CAACG,MAAM,CAACC,aAAR,CAAN,GACZJ,MAAD,CAAuCG,MAAM,CAACC,aAA9C,GADa,GAEZJ,MAAD,CAAkCG,MAAM,CAACD,QAAzC,GAFJ;AAIA,SAAO,IAAIG,cAAJ,CACL;AAKEC,IAAAA,IAAI,EAAE,OALR;;AAOE,UAAMC,IAAN,CAAWC,UAAX,EAAuB;AACrB,UAAI;AACF,cAAM;AAACC,UAAAA,IAAD;AAAOC,UAAAA;AAAP,YAAgB,MAAMR,QAAQ,CAACS,IAAT,EAA5B;;AACA,YAAIF,IAAJ,EAAU;AACRD,UAAAA,UAAU,CAACI,KAAX;AACD,SAFD,MAEO;AAELJ,UAAAA,UAAU,CAACK,OAAX,CAAmB,IAAIC,UAAJ,CAAeJ,KAAf,CAAnB;AACD;AACF,OARD,CAQE,OAAOK,KAAP,EAAc;AACdP,QAAAA,UAAU,CAACO,KAAX,CAAiBA,KAAjB;AACD;AACF,KAnBH;;AAqBE,UAAMC,MAAN,GAAe;AAAA;;AACb,aAAMd,QAAN,aAAMA,QAAN,2CAAMA,QAAQ,CAAEe,MAAhB,qDAAM,sBAAAf,QAAQ,CAAd;AACD;;AAvBH,GADK,EA2BL;AAEEgB,IAAAA,aAAa,EAAE,KAAK,EAFtB;AAGE,OAAGjB;AAHL,GA3BK,CAAP;AAiCD","sourcesContent":["export type MakeStreamOptions = {\n  /** Stream allocates an arrayBuffer. Enables use of a default reader. */\n  autoAllocateChunkSize?: number;\n  /** Total number of chunks in queue before back pressure is applied */\n  highWaterMark?: number;\n};\n\n/**\n * Builds a DOM stream from an iterator\n * This stream is currently used in browsers only,\n * but note that Web stream support is present in Node from Node 16\n * https://nodejs.org/api/webstreams.html#webstreams_web_streams_api\n */\nexport function makeStream<ArrayBuffer>(\n  source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>,\n  options?: MakeStreamOptions\n): ReadableStream {\n  const iterator = source[Symbol.asyncIterator]\n    ? (source as AsyncIterable<ArrayBuffer>)[Symbol.asyncIterator]()\n    : (source as Iterable<ArrayBuffer>)[Symbol.iterator]();\n\n  return new ReadableStream<Uint8Array>(\n    {\n      // Create a byte stream (enables `Response(stream).arrayBuffer()`)\n      // Only supported on Chrome\n      // See: https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController\n      // @ts-expect-error Only Chrome supports byte streams\n      type: 'bytes',\n\n      async pull(controller) {\n        try {\n          const {done, value} = await iterator.next();\n          if (done) {\n            controller.close();\n          } else {\n            // TODO - ignores controller.desiredSize\n            controller.enqueue(new Uint8Array(value));\n          }\n        } catch (error) {\n          controller.error(error);\n        }\n      },\n\n      async cancel() {\n        await iterator?.return?.();\n      }\n    },\n    // options: QueingStrategy<Uint8Array>\n    {\n      // This is bytes, not chunks\n      highWaterMark: 2 ** 24,\n      ...options\n    }\n  );\n}\n"],"file":"make-dom-stream.js"}

package/dist/iterators/make-stream/make-node-stream.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/iterators/make-stream/make-node-stream.ts"],"names":["Readable","makeStream","source","options","iterator","Symbol","asyncIterator","AsyncIterableReadable","constructor","it","_iterator","_pulling","_bytesMode","objectMode","_read","size","_pull","_destroy","error","cb","throw","return","bm","r","readable","next","done","ArrayBuffer","isView","value","byteLength","push","Uint8Array"],"mappings":";AAAA,SAAQA,QAAR,QAAwC,QAAxC;AAKA,OAAO,SAASC,UAAT,CACLC,MADK,EAELC,OAFK,EAGK;AACV,QAAMC,QAAQ,GAAGF,MAAM,CAACG,MAAM,CAACC,aAAR,CAAN,GACbJ,MAAM,CAACG,MAAM,CAACC,aAAR,CAAN,EADa,GAEbJ,MAAM,CAACG,MAAM,CAACD,QAAR,CAAN,EAFJ;AAGA,SAAO,IAAIG,qBAAJ,CAA0BH,QAA1B,EAAoCD,OAApC,CAAP;AACD;;AAED,MAAMI,qBAAN,SAAoCP,QAApC,CAA6C;AAK3CQ,EAAAA,WAAW,CAACC,EAAD,EAAiCN,OAAjC,EAA4D;AACrE,UAAMA,OAAN;;AADqE;;AAAA;;AAAA;;AAErE,SAAKO,SAAL,GAAiBD,EAAjB;AACA,SAAKE,QAAL,GAAgB,KAAhB;AACA,SAAKC,UAAL,GAAkB,CAACT,OAAD,IAAY,CAACA,OAAO,CAACU,UAAvC;AACD;;AAEU,QAALC,KAAK,CAACC,IAAD,EAA8B;AACvC,QAAI,CAAC,KAAKJ,QAAV,EAAoB;AAClB,WAAKA,QAAL,GAAgB,IAAhB;AACA,WAAKA,QAAL,GAAgB,MAAM,KAAKK,KAAL,CAAWD,IAAX,EAAiB,KAAKL,SAAtB,CAAtB;AACD;AACF;;AAEa,QAARO,QAAQ,CAACC,KAAD,EAAsBC,EAAtB,EAAoE;AAChF,QAAI,CAAC,KAAKT,SAAV,EAAqB;AACnB;AACD;;AACD,QAAIQ,KAAJ,EAAW;AAAA;;AACT,gCAAM,KAAKR,SAAX,6EAAM,gBAAgBU,KAAtB,0DAAM,4CAAwBF,KAAxB,CAAN;AACD,KAFD,MAEO;AAAA;;AACL,iCAAM,KAAKR,SAAX,8EAAM,iBAAgBW,MAAtB,0DAAM,6CAAyBH,KAAzB,CAAN;AACD;;AACDC,IAAAA,EAAE,SAAF,IAAAA,EAAE,WAAF,YAAAA,EAAE,CAAG,IAAH,CAAF;AACD;;AAGkB,QAALH,KAAK,CAACD,IAAD,EAAeN,EAAf,EAAiE;AAAA;;AAClF,UAAMa,EAAE,GAAG,KAAKV,UAAhB;AACA,QAAIW,CAAqC,GAAG,IAA5C;;AAEA,WAAO,KAAKC,QAAL,IAAiB,CAAC,CAACD,CAAC,GAAG,MAAMd,EAAE,CAACgB,IAAH,EAAX,EAAsBC,IAA/C,EAAqD;AACnD,UAAIX,IAAI,KAAK,IAAb,EAAmB;AACjBA,QAAAA,IAAI,IAAIO,EAAE,IAAIK,WAAW,CAACC,MAAZ,CAAmBL,CAAC,CAACM,KAArB,CAAN,GAAoCN,CAAC,CAACM,KAAF,CAAQC,UAA5C,GAAyD,CAAjE;AACD;;AACD,UAAI,CAAC,KAAKC,IAAL,CAAU,IAAIC,UAAJ,CAAeT,CAAC,CAACM,KAAjB,CAAV,CAAD,IAAuCd,IAAI,IAAI,CAAnD,EAAsD;AACpD;AACD;AACF;;AACD,QAAI,CAAC,MAAAQ,CAAC,UAAD,wBAAGG,IAAH,IAAW,CAAC,KAAKF,QAAlB,MAAgC,KAAKO,IAAL,CAAU,IAAV,KAAmB,IAAnD,CAAJ,EAA8D;AAAA;;AAC5DtB,MAAAA,EAAE,SAAF,IAAAA,EAAE,WAAF,0BAAAA,EAAE,CAAEY,MAAJ,+DAAAZ,EAAE;AACH;;AACD,WAAO,CAAC,KAAKe,QAAb;AACD;;AAhD0C","sourcesContent":["import {Readable, ReadableOptions} from 'stream';\n\nexport type MakeStreamOptions = ReadableOptions;\n\n/** Builds a node stream from an iterator */\nexport function makeStream<ArrayBuffer>(\n  source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>,\n  options?: ReadableOptions\n): Readable {\n  const iterator = source[Symbol.asyncIterator]\n    ? source[Symbol.asyncIterator]()\n    : source[Symbol.iterator]();\n  return new AsyncIterableReadable(iterator, options);\n}\n\nclass AsyncIterableReadable extends Readable {\n  private _pulling: boolean;\n  private _bytesMode: boolean;\n  private _iterator: AsyncIterator<ArrayBuffer>;\n\n  constructor(it: AsyncIterator<ArrayBuffer>, options?: ReadableOptions) {\n    super(options);\n    this._iterator = it;\n    this._pulling = false;\n    this._bytesMode = !options || !options.objectMode;\n  }\n\n  async _read(size: number): Promise<void> {\n    if (!this._pulling) {\n      this._pulling = true;\n      this._pulling = await this._pull(size, this._iterator);\n    }\n  }\n\n  async _destroy(error: Error | null, cb: (e: Error | null) => void): Promise<void> {\n    if (!this._iterator) {\n      return;\n    }\n    if (error) {\n      await this._iterator?.throw?.(error);\n    } else {\n      await this._iterator?.return?.(error);\n    }\n    cb?.(null);\n  }\n\n  // eslint-disable-next-line complexity\n  private async _pull(size: number, it: AsyncIterator<ArrayBuffer>): Promise<boolean> {\n    const bm = this._bytesMode;\n    let r: IteratorResult<ArrayBuffer> | null = null;\n    // while (this.readable && !(r = await it.next(bm ? size : null)).done) {\n    while (this.readable && !(r = await it.next()).done) {\n      if (size !== null) {\n        size -= bm && ArrayBuffer.isView(r.value) ? r.value.byteLength : 1;\n      }\n      if (!this.push(new Uint8Array(r.value)) || size <= 0) {\n        break;\n      }\n    }\n    if ((r?.done || !this.readable) && (this.push(null) || true)) {\n      it?.return?.();\n    }\n    return !this.readable;\n  }\n}\n"],"file":"make-node-stream.js"}

package/dist/javascript-utils/is-type.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/javascript-utils/is-type.ts"],"names":["isBoolean","x","isFunction","isObject","isPureObject","constructor","isPromise","then","isIterable","Symbol","iterator","isAsyncIterable","asyncIterator","isIterator","next","isResponse","Response","arrayBuffer","text","json","isFile","File","isBlob","Blob","isBuffer","isWritableDOMStream","abort","getWriter","isReadableDOMStream","ReadableStream","tee","cancel","getReader","isWritableNodeStream","end","write","writable","isReadableNodeStream","read","pipe","readable","isReadableStream","isWritableStream"],"mappings":"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","sourcesContent":["import type {Readable} from 'stream';\n\n/** A DOM or Node readable stream */\nexport type ReadableStreamType = ReadableStream | Readable;\n\nconst isBoolean: (x: any) => boolean = (x) => typeof x === 'boolean';\nconst isFunction: (x: any) => boolean = (x) => typeof x === 'function';\n\nexport const isObject: (x: any) => boolean = (x) => x !== null && typeof x === 'object';\nexport const isPureObject: (x: any) => boolean = (x) =>\n  isObject(x) && x.constructor === {}.constructor;\nexport const isPromise: (x: any) => boolean = (x) => isObject(x) && isFunction(x.then);\n\nexport const isIterable: (x: any) => boolean = (x) => x && typeof x[Symbol.iterator] === 'function';\nexport const isAsyncIterable: (x: any) => boolean = (x) =>\n  x && typeof x[Symbol.asyncIterator] === 'function';\nexport const isIterator: (x: any) => boolean = (x) => x && isFunction(x.next);\n\nexport const isResponse: (x: any) => boolean = (x) =>\n  (typeof Response !== 'undefined' && x instanceof Response) ||\n  (x && x.arrayBuffer && x.text && x.json);\n\nexport const isFile: (x: any) => boolean = (x) => typeof File !== 'undefined' && x instanceof File;\nexport const isBlob: (x: any) => boolean = (x) => typeof Blob !== 'undefined' && x instanceof Blob;\n\n/** Check for Node.js `Buffer` without triggering bundler to include buffer polyfill */\nexport const isBuffer: (x: any) => boolean = (x) => x && typeof x === 'object' && x.isBuffer;\n\nexport const isWritableDOMStream: (x: any) => boolean = (x) =>\n  isObject(x) && isFunction(x.abort) && isFunction(x.getWriter);\n\nexport const isReadableDOMStream: (x: any) => boolean = (x) =>\n  (typeof ReadableStream !== 'undefined' && x instanceof ReadableStream) ||\n  (isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader));\n// Not implemented in Firefox: && isFunction(x.pipeTo)\n\nexport const isWritableNodeStream: (x: any) => boolean = (x) =>\n  isObject(x) && isFunction(x.end) && isFunction(x.write) && isBoolean(x.writable);\nexport const isReadableNodeStream: (x: any) => boolean = (x) =>\n  isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);\nexport const isReadableStream: (x: any) => boolean = (x) =>\n  isReadableDOMStream(x) || isReadableNodeStream(x);\nexport const isWritableStream: (x: any) => boolean = (x) =>\n  isWritableDOMStream(x) || isWritableNodeStream(x);\n"],"file":"is-type.js"}

package/dist/lib/api/encode.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/api/encode.ts"],"names":["concatenateArrayBuffers","resolvePath","isBrowser","writeFile","fetchFile","encode","data","writer","options","encodeSync","encodeText","TextEncoder","encodeInBatches","batches","chunks","batch","push","encodeURLtoURL","tmpInputFilename","getTemporaryFilename","tmpOutputFilename","outputFilename","response","arrayBuffer","Error","text","TextDecoder","decode","dataIterator","getIterator","inputUrl","outputUrl","table","start","end","length","filename"],"mappings":"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","sourcesContent":["import type {Writer, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {concatenateArrayBuffers, resolvePath} from '@loaders.gl/loader-utils';\nimport {isBrowser} from '@loaders.gl/loader-utils';\nimport {writeFile} from '../fetch/write-file';\nimport {fetchFile} from '../fetch/fetch-file';\n\n/**\n * Encode loaded data into a binary ArrayBuffer using the specified Writer.\n */\nexport async function encode(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): Promise<ArrayBuffer> {\n  // TODO Merge default writer options with options argument like it is done in load module.\n  if (writer.encode) {\n    return await writer.encode(data, options);\n  }\n\n  if (writer.encodeSync) {\n    return writer.encodeSync(data, options);\n  }\n\n  if (writer.encodeText) {\n    return new TextEncoder().encode(await writer.encodeText(data, options));\n  }\n\n  if (writer.encodeInBatches) {\n    // Create an iterator representing the data\n    // TODO - Assumes this is a table\n    const batches = encodeInBatches(data, writer, options);\n\n    // Concatenate the output\n    const chunks: any[] = [];\n    for await (const batch of batches) {\n      chunks.push(batch);\n    }\n    // @ts-ignore\n    return concatenateArrayBuffers(...chunks);\n  }\n\n  if (!isBrowser && writer.encodeURLtoURL) {\n    // TODO - how to generate filenames with correct extensions?\n    const tmpInputFilename = getTemporaryFilename('input');\n    await writeFile(tmpInputFilename, data);\n\n    const tmpOutputFilename = getTemporaryFilename('output');\n\n    const outputFilename = await encodeURLtoURL(\n      tmpInputFilename,\n      tmpOutputFilename,\n      writer,\n      options\n    );\n\n    const response = await fetchFile(outputFilename);\n    return response.arrayBuffer();\n  }\n\n  throw new Error('Writer could not encode data');\n}\n\n/**\n * Encode loaded data into a binary ArrayBuffer using the specified Writer.\n */\nexport function encodeSync(data: any, writer: Writer, options?: LoaderOptions): ArrayBuffer {\n  if (writer.encodeSync) {\n    return writer.encodeSync(data, options);\n  }\n  throw new Error('Writer could not synchronously encode data');\n}\n\n/**\n * Encode loaded data to text using the specified Writer\n * @note This is a convenience function not intended for production use on large input data.\n * It is not optimized for performance. Data maybe converted from text to binary and back.\n * @throws if the writer does not generate text output\n */\nexport async function encodeText(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): Promise<string> {\n  if (writer.text && writer.encodeText) {\n    return await writer.encodeText(data, options);\n  }\n\n  if (writer.text && (writer.encode || writer.encodeInBatches)) {\n    const arrayBuffer = await encode(data, writer, options);\n    return new TextDecoder().decode(arrayBuffer);\n  }\n\n  throw new Error('Writer could not encode data as text');\n}\n\n/**\n * Encode loaded data into a sequence (iterator) of binary ArrayBuffers using the specified Writer.\n */\nexport function encodeInBatches(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): AsyncIterable<ArrayBuffer> {\n  if (writer.encodeInBatches) {\n    const dataIterator = getIterator(data);\n    return writer.encodeInBatches(dataIterator, options);\n  }\n  // TODO -fall back to atomic encode?\n  throw new Error('Writer could not encode data in batches');\n}\n\n/**\n * Encode data stored in a file (on disk) to another file.\n * @note Node.js only. This function enables using command-line converters as \"writers\".\n */\nexport async function encodeURLtoURL(\n  inputUrl,\n  outputUrl,\n  writer: Writer,\n  options\n): Promise<string> {\n  inputUrl = resolvePath(inputUrl);\n  outputUrl = resolvePath(outputUrl);\n  if (isBrowser || !writer.encodeURLtoURL) {\n    throw new Error();\n  }\n  const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);\n  return outputFilename;\n}\n\n/**\n * @todo TODO - this is an unacceptable hack!!!\n */\nfunction getIterator(data) {\n  const dataIterator = [{table: data, start: 0, end: data.length}];\n  return dataIterator;\n}\n\n/**\n * @todo Move to utils\n */\nfunction getTemporaryFilename(filename: string): string {\n  return `/tmp/${filename}`;\n}\n"],"file":"encode.js"}

package/dist/lib/api/load-in-batches.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/api/load-in-batches.ts"],"names":["isLoaderObject","getFetchFunction","parseInBatches","loadInBatches","files","loaders","options","context","Array","isArray","undefined","fetch","loadOneFileInBatches","promises","map","file","url","response"],"mappings":"AACA,SAAQA,cAAR,QAA6B,kCAA7B;AACA,SAAQC,gBAAR,QAA+B,8BAA/B;AAEA,SAAQC,cAAR,QAA6B,oBAA7B;AAyBA,OAAO,SAASC,aAAT,CAAuBC,KAAvB,EAA8BC,OAA9B,EAAuCC,OAAvC,EAAgDC,OAAhD,EAAyD;AAE9D,MAAI,CAACC,KAAK,CAACC,OAAN,CAAcJ,OAAd,CAAD,IAA2B,CAACL,cAAc,CAACK,OAAD,CAA9C,EAAyD;AACvDE,IAAAA,OAAO,GAAGG,SAAV;AACAJ,IAAAA,OAAO,GAAGD,OAAV;AACAA,IAAAA,OAAO,GAAG,IAAV;AACD;;AAGD,QAAMM,KAAK,GAAGV,gBAAgB,CAACK,OAAO,IAAI,EAAZ,CAA9B;;AAGA,MAAI,CAACE,KAAK,CAACC,OAAN,CAAcL,KAAd,CAAL,EAA2B;AACzB,WAAOQ,oBAAoB,CAACR,KAAD,EAAQC,OAAR,EAAiBC,OAAjB,EAA0BK,KAA1B,CAA3B;AACD;;AAGD,QAAME,QAAQ,GAAGT,KAAK,CAACU,GAAN,CAAWC,IAAD,IAAUH,oBAAoB,CAACG,IAAD,EAAOV,OAAP,EAAgBC,OAAhB,EAAyBK,KAAzB,CAAxC,CAAjB;AAGA,SAAOE,QAAP;AACD;;AAED,eAAeD,oBAAf,CAAoCG,IAApC,EAA0CV,OAA1C,EAAmDC,OAAnD,EAA4DK,KAA5D,EAAmE;AACjE,MAAI,OAAOI,IAAP,KAAgB,QAApB,EAA8B;AAC5B,UAAMC,GAAG,GAAGD,IAAZ;AACA,UAAME,QAAQ,GAAG,MAAMN,KAAK,CAACK,GAAD,CAA5B;AACA,WAAO,MAAMd,cAAc,CAACe,QAAD,EAAWZ,OAAX,EAAoBC,OAApB,CAA3B;AACD;;AACD,SAAO,MAAMJ,cAAc,CAACa,IAAD,EAAOV,OAAP,EAAgBC,OAAhB,CAA3B;AACD","sourcesContent":["import type {LoaderWithParser, LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/option-utils';\n\nimport {parseInBatches} from './parse-in-batches';\n\ntype FileType = string | File | Blob | Response | (string | File | Blob | Response)[] | FileList;\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport function loadInBatches(\n  files: FileType,\n  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<any>>;\n\nexport function loadInBatches(\n  files: FileType[] | FileList,\n  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<any>>;\n\nexport function loadInBatches(files, loaders, options, context) {\n  // Signature: load(url, options)\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders;\n    loaders = null;\n  }\n\n  // Select fetch function\n  const fetch = getFetchFunction(options || {});\n\n  // Single url/file\n  if (!Array.isArray(files)) {\n    return loadOneFileInBatches(files, loaders, options, fetch);\n  }\n\n  // Multiple URLs / files\n  const promises = files.map((file) => loadOneFileInBatches(file, loaders, options, fetch));\n\n  // No point in waiting here for all responses before starting to stream individual streams?\n  return promises;\n}\n\nasync function loadOneFileInBatches(file, loaders, options, fetch) {\n  if (typeof file === 'string') {\n    const url = file;\n    const response = await fetch(url);\n    return await parseInBatches(response, loaders, options);\n  }\n  return await parseInBatches(file, loaders, options);\n}\n"],"file":"load-in-batches.js"}

package/dist/lib/api/load.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/api/load.ts"],"names":["isBlob","isLoaderObject","getFetchFunction","parse","load","url","loaders","options","context","Array","isArray","undefined","fetch","data"],"mappings":"AACA,SAAQA,MAAR,QAAqB,gCAArB;AACA,SAAQC,cAAR,QAA6B,kCAA7B;AACA,SAAQC,gBAAR,QAA+B,8BAA/B;AAEA,SAAQC,KAAR,QAAoB,SAApB;AAYA,OAAO,eAAeC,IAAf,CACLC,GADK,EAELC,OAFK,EAGLC,OAHK,EAILC,OAJK,EAKS;AAEd,MAAI,CAACC,KAAK,CAACC,OAAN,CAAcJ,OAAd,CAAD,IAA2B,CAACL,cAAc,CAACK,OAAD,CAA9C,EAAyD;AACvDE,IAAAA,OAAO,GAAGG,SAAV;AACAJ,IAAAA,OAAO,GAAGD,OAAV;AACAA,IAAAA,OAAO,GAAGK,SAAV;AACD;;AAGD,QAAMC,KAAK,GAAGV,gBAAgB,CAACK,OAAD,CAA9B;AAGA,MAAIM,IAAI,GAAGR,GAAX;;AAEA,MAAI,OAAOA,GAAP,KAAe,QAAnB,EAA6B;AAC3BQ,IAAAA,IAAI,GAAG,MAAMD,KAAK,CAACP,GAAD,CAAlB;AAED;;AAED,MAAIL,MAAM,CAACK,GAAD,CAAV,EAAiB;AAEfQ,IAAAA,IAAI,GAAG,MAAMD,KAAK,CAACP,GAAD,CAAlB;AACD;;AAGD,SAAO,MAAMF,KAAK,CAACU,IAAD,EAAOP,OAAP,EAAgBC,OAAhB,CAAlB;AACD","sourcesContent":["import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {isBlob} from '../../javascript-utils/is-type';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/option-utils';\n\nimport {parse} from './parse';\n\n/**\n * Parses `data` using a specified loader\n * Note: Load does duplicate a lot of parse.\n * it can also call fetchFile on string urls, which `parse` won't do.\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\n// implementation signature\nexport async function load(\n  url: string | DataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<any> {\n  // Signature: load(url, options)\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loaders = undefined;\n  }\n\n  // Select fetch function\n  const fetch = getFetchFunction(options);\n\n  // at this point, `url` could be already loaded binary data\n  let data = url;\n  // url is a string, fetch the url\n  if (typeof url === 'string') {\n    data = await fetch(url);\n    // URL is Blob or File, fetchFile handles it (alt: we could generate ObjectURL here)\n  }\n\n  if (isBlob(url)) {\n    // The fetch response object will contain blob.name\n    data = await fetch(url);\n  }\n\n  // Data is loaded (at least we have a `Response` object) so time to hand over to `parse`\n  return await parse(data, loaders, options);\n}\n"],"file":"load.js"}

package/dist/lib/api/parse-in-batches.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/api/parse-in-batches.ts"],"names":["assert","concatenateArrayBuffersAsync","isLoaderObject","normalizeOptions","getLoaderContext","getAsyncIterableFromData","getResourceUrlAndType","selectLoader","parse","parseInBatches","data","loaders","options","context","Array","isArray","undefined","url","loader","parseWithLoaderInBatches","outputIterator","parseToOutputIterator","metadata","metadataBatch","batchType","_loader","_context","bytesUsed","makeMetadataBatchIterator","iterator","inputIterator","transformedIterator","applyInputTransforms","transforms","parseChunkInBatches","arrayBuffer","parsedData","mimeType","mimeTypes","batch","shape","length","iteratorChain","transformBatches"],"mappings":"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","sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport type {\n  BatchableDataType,\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions\n} from '@loaders.gl/loader-utils';\nimport {assert, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getLoaderContext} from '../loader-utils/loader-context';\nimport {getAsyncIterableFromData} from '../loader-utils/get-data';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n// Ensure `parse` is available in context if loader falls back to `parse`\nimport {parse} from './parse';\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport async function parseInBatches(\n  data: BatchableDataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<any>> {\n  assert(!context || typeof context === 'object'); // parseInBatches no longer accepts final url\n\n  // Signature: parseInBatches(data, options, url) - Uses registered loaders\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loaders = undefined;\n  }\n\n  data = await data; // Resolve any promise\n  options = options || {};\n\n  // Extract a url for auto detection\n  const {url} = getResourceUrlAndType(data);\n\n  // Chooses a loader and normalizes it\n  // Note - only uses URL and contentType for streams and iterator inputs\n  const loader = await selectLoader(data as ArrayBuffer, loaders as Loader[], options);\n  // Note: if options.nothrow was set, it is possible that no loader was found, if so just return null\n  if (!loader) {\n    // @ts-ignore\n    return null;\n  }\n\n  // Normalize options\n  // @ts-ignore\n  options = normalizeOptions(options, loader, loaders, url);\n  // @ts-ignore\n  context = getLoaderContext(\n    // @ts-ignore\n    {url, parseInBatches, parse, loaders: loaders as Loader[]},\n    options,\n    context\n  );\n\n  return await parseWithLoaderInBatches(loader as LoaderWithParser, data, options, context);\n}\n\n/**\n * Loader has been selected and context has been prepared, see if we need to emit a metadata batch\n */\nasync function parseWithLoaderInBatches(\n  loader: LoaderWithParser,\n  data: BatchableDataType,\n  options: LoaderOptions,\n  context: LoaderContext\n): Promise<AsyncIterable<any>> {\n  const outputIterator = await parseToOutputIterator(loader, data, options, context);\n\n  // Generate metadata batch if requested\n  if (!options.metadata) {\n    return outputIterator;\n  }\n\n  const metadataBatch = {\n    batchType: 'metadata',\n    metadata: {\n      _loader: loader,\n      _context: context\n    },\n    // Populate with some default fields to avoid crashing\n    data: [],\n    bytesUsed: 0\n  };\n\n  async function* makeMetadataBatchIterator(iterator) {\n    yield metadataBatch;\n    yield* iterator;\n  }\n\n  return makeMetadataBatchIterator(outputIterator);\n}\n\n/**\n * Prep work is done, now it is time to start parsing into an output operator\n * The approach depends on which parse function the loader exposes\n * `parseInBatches` (preferred), `parse` (fallback)\n */\nasync function parseToOutputIterator(\n  loader: LoaderWithParser,\n  data: BatchableDataType,\n  options: LoaderOptions,\n  context: LoaderContext\n): Promise<AsyncIterable<any>> {\n  // Get an iterator from the input\n  const inputIterator = await getAsyncIterableFromData(data, options);\n\n  // Apply any iterator transforms (options.transforms)\n  const transformedIterator = await applyInputTransforms(inputIterator, options?.transforms || []);\n\n  // If loader supports parseInBatches, we are done\n  if (loader.parseInBatches) {\n    return loader.parseInBatches(transformedIterator, options, context);\n  }\n\n  // Fallback: load atomically using `parse` concatenating input iterator into single chunk\n  async function* parseChunkInBatches() {\n    const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);\n    // Call `parse` instead of `loader.parse` to ensure we can call workers etc.\n    const parsedData = await parse(\n      arrayBuffer,\n      loader,\n      // TODO - Hack: supply loaders MIME type to ensure we match it\n      {...options, mimeType: loader.mimeTypes[0]},\n      context\n    );\n    // yield a single batch, the output from loader.parse()\n    // TODO - run through batch builder to apply options etc...\n    const batch: Batch = {\n      mimeType: loader.mimeTypes[0],\n      shape: Array.isArray(parsedData) ? 'row-table' : 'unknown',\n      batchType: 'data',\n      data: parsedData,\n      length: Array.isArray(parsedData) ? parsedData.length : 1\n    };\n    yield batch;\n  }\n\n  return parseChunkInBatches();\n}\n\ntype TransformBatches = (\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n) => AsyncIterable<ArrayBuffer>;\n\n/**\n * Create an iterator chain with any transform iterators (crypto, decompression)\n * @param inputIterator\n * @param options\n */\nasync function applyInputTransforms(\n  inputIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  transforms: TransformBatches[] = []\n): Promise<AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>> {\n  let iteratorChain = inputIterator;\n  for await (const transformBatches of transforms) {\n    iteratorChain = transformBatches(iteratorChain);\n  }\n  return iteratorChain;\n}\n"],"file":"parse-in-batches.js"}

package/dist/lib/api/parse-sync.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/api/parse-sync.ts"],"names":["assert","selectLoaderSync","isLoaderObject","normalizeOptions","getArrayBufferOrStringFromDataSync","getLoaderContext","getLoadersFromContext","getResourceUrlAndType","parseSync","data","loaders","options","context","Array","isArray","undefined","typedLoaders","candidateLoaders","loader","url","parse","Error","parseWithLoaderSync","parseTextSync","ArrayBuffer","name"],"mappings":"AAOA,SAAQA,MAAR,QAAqB,0BAArB;AACA,SAAQC,gBAAR,QAA+B,iBAA/B;AACA,SAAQC,cAAR,QAA6B,kCAA7B;AACA,SAAQC,gBAAR,QAA+B,8BAA/B;AACA,SAAQC,kCAAR,QAAiD,0BAAjD;AACA,SAAQC,gBAAR,EAA0BC,qBAA1B,QAAsD,gCAAtD;AACA,SAAQC,qBAAR,QAAoC,yBAApC;AASA,OAAO,SAASC,SAAT,CACLC,IADK,EAELC,OAFK,EAGLC,OAHK,EAILC,OAJK,EAKA;AACLZ,EAAAA,MAAM,CAAC,CAACY,OAAD,IAAY,OAAOA,OAAP,KAAmB,QAAhC,CAAN;;AAIA,MAAI,CAACC,KAAK,CAACC,OAAN,CAAcJ,OAAd,CAAD,IAA2B,CAACR,cAAc,CAACQ,OAAD,CAA9C,EAAyD;AACvDE,IAAAA,OAAO,GAAGG,SAAV;AACAJ,IAAAA,OAAO,GAAGD,OAAV;AACAA,IAAAA,OAAO,GAAGK,SAAV;AACD;;AAEDJ,EAAAA,OAAO,GAAGA,OAAO,IAAI,EAArB;AAIA,QAAMK,YAAY,GAAGN,OAArB;AACA,QAAMO,gBAAgB,GAAGX,qBAAqB,CAACU,YAAD,EAAeJ,OAAf,CAA9C;AACA,QAAMM,MAAM,GAAGjB,gBAAgB,CAACQ,IAAD,EAAOQ,gBAAP,EAAyBN,OAAzB,CAA/B;;AAEA,MAAI,CAACO,MAAL,EAAa;AACX,WAAO,IAAP;AACD;;AAGDP,EAAAA,OAAO,GAAGR,gBAAgB,CAACQ,OAAD,EAAUO,MAAV,EAAkBD,gBAAlB,CAA1B;AAGA,QAAM;AAACE,IAAAA;AAAD,MAAQZ,qBAAqB,CAACE,IAAD,CAAnC;;AAEA,QAAMW,KAAK,GAAG,MAAM;AAClB,UAAM,IAAIC,KAAJ,CAAU,wBAAV,CAAN;AACD,GAFD;;AAGAT,EAAAA,OAAO,GAAGP,gBAAgB,CAAC;AAACc,IAAAA,GAAD;AAAMX,IAAAA,SAAN;AAAiBY,IAAAA,KAAjB;AAAwBV,IAAAA,OAAO,EAAEA;AAAjC,GAAD,EAAwDC,OAAxD,CAA1B;AAEA,SAAOW,mBAAmB,CAACJ,MAAD,EAA6BT,IAA7B,EAAmCE,OAAnC,EAA4CC,OAA5C,CAA1B;AACD;;AAGD,SAASU,mBAAT,CACEJ,MADF,EAEET,IAFF,EAGEE,OAHF,EAIEC,OAJF,EAKE;AACAH,EAAAA,IAAI,GAAGL,kCAAkC,CAACK,IAAD,EAAOS,MAAP,EAAeP,OAAf,CAAzC;;AAEA,MAAIO,MAAM,CAACK,aAAP,IAAwB,OAAOd,IAAP,KAAgB,QAA5C,EAAsD;AACpD,WAAOS,MAAM,CAACK,aAAP,CAAqBd,IAArB,EAA2BE,OAA3B,CAAP;AACD;;AAED,MAAIO,MAAM,CAACV,SAAP,IAAoBC,IAAI,YAAYe,WAAxC,EAAqD;AACnD,WAAON,MAAM,CAACV,SAAP,CAAiBC,IAAjB,EAAuBE,OAAvB,EAAgCC,OAAhC,CAAP;AACD;;AAGD,QAAM,IAAIS,KAAJ,WACDH,MAAM,CAACO,IADN,qFAEFb,OAAO,CAACO,GAAR,IAAe,EAFb,EAAN;AAKD","sourcesContent":["import type {\n  SyncDataType,\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions\n} from '@loaders.gl/loader-utils';\nimport {assert} from '@loaders.gl/loader-utils';\nimport {selectLoaderSync} from './select-loader';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getArrayBufferOrStringFromDataSync} from '../loader-utils/get-data';\nimport {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\n\n/**\n * Parses `data` synchronously using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport function parseSync(\n  data: SyncDataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): any {\n  assert(!context || typeof context === 'object'); // parseSync no longer accepts final url\n\n  // Signature: parseSync(data, options)\n  // Uses registered loaders\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loaders = undefined;\n  }\n\n  options = options || {};\n\n  // Chooses a loader (and normalizes it)\n  // Also use any loaders in the context, new loaders take priority\n  const typedLoaders = loaders as Loader | Loader[] | undefined;\n  const candidateLoaders = getLoadersFromContext(typedLoaders, context);\n  const loader = selectLoaderSync(data, candidateLoaders, options);\n  // Note: if nothrow option was set, it is possible that no loader was found, if so just return null\n  if (!loader) {\n    return null;\n  }\n\n  // Normalize options\n  options = normalizeOptions(options, loader, candidateLoaders);\n\n  // Extract a url for auto detection\n  const {url} = getResourceUrlAndType(data);\n\n  const parse = () => {\n    throw new Error('parseSync called parse');\n  };\n  context = getLoaderContext({url, parseSync, parse, loaders: loaders as Loader[]}, options);\n\n  return parseWithLoaderSync(loader as LoaderWithParser, data, options, context);\n}\n\n// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator\nfunction parseWithLoaderSync(\n  loader: LoaderWithParser,\n  data: SyncDataType,\n  options: LoaderOptions,\n  context: LoaderContext\n) {\n  data = getArrayBufferOrStringFromDataSync(data, loader, options);\n\n  if (loader.parseTextSync && typeof data === 'string') {\n    return loader.parseTextSync(data, options); // , context, loader);\n  }\n\n  if (loader.parseSync && data instanceof ArrayBuffer) {\n    return loader.parseSync(data, options, context); // , loader);\n  }\n\n  // TBD - If synchronous parser not available, return null\n  throw new Error(\n    `${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${\n      context.url || ''\n    }`\n  );\n}\n"],"file":"parse-sync.js"}

package/dist/lib/api/parse.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/api/parse.ts"],"names":["assert","validateWorkerVersion","parseWithWorker","canParseWithWorker","isLoaderObject","normalizeOptions","getArrayBufferOrStringFromData","getLoaderContext","getLoadersFromContext","getResourceUrlAndType","selectLoader","parse","data","loaders","options","context","Array","isArray","undefined","url","typedLoaders","candidateLoaders","loader","parseWithLoader","parseTextSync","dataType","parseText","parseSync","Error","id"],"mappings":"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","sourcesContent":["import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';\nimport {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getArrayBufferOrStringFromData} from '../loader-utils/get-data';\nimport {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<any> {\n  assert(!context || typeof context === 'object'); // parse no longer accepts final url\n\n  // Signature: parse(data, options, context | url)\n  // Uses registered loaders\n  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loaders = undefined;\n  }\n\n  data = await data; // Resolve any promise\n  options = options || {};\n\n  // Extract a url for auto detection\n  const {url} = getResourceUrlAndType(data);\n\n  // Chooses a loader (and normalizes it)\n  // Also use any loaders in the context, new loaders take priority\n  const typedLoaders = loaders as Loader | Loader[] | undefined;\n  const candidateLoaders = getLoadersFromContext(typedLoaders, context);\n  // todo hacky type cast\n  const loader = await selectLoader(data as ArrayBuffer, candidateLoaders, options);\n  // Note: if no loader was found, if so just return null\n  if (!loader) {\n    return null;\n  }\n\n  // Normalize options\n  options = normalizeOptions(options, loader, candidateLoaders, url);\n\n  // Get a context (if already present, will be unchanged)\n  context = getLoaderContext({url, parse, loaders: candidateLoaders}, options, context);\n\n  return await parseWithLoader(loader, data, options, context);\n}\n\n// TODO: support progress and abort\n// TODO - should accept loader.parseAsyncIterator and concatenate.\nasync function parseWithLoader(loader, data, options, context) {\n  validateWorkerVersion(loader);\n\n  data = await getArrayBufferOrStringFromData(data, loader, options);\n\n  // First check for synchronous text parser, wrap results in promises\n  if (loader.parseTextSync && typeof data === 'string') {\n    options.dataType = 'text';\n    return loader.parseTextSync(data, options, context, loader);\n  }\n\n  // If we have a workerUrl and the loader can parse the given options efficiently in a worker\n  if (canParseWithWorker(loader, options)) {\n    return await parseWithWorker(loader, data, options, context, parse);\n  }\n\n  // Check for asynchronous parser\n  if (loader.parseText && typeof data === 'string') {\n    return await loader.parseText(data, options, context, loader);\n  }\n\n  if (loader.parse) {\n    return await loader.parse(data, options, context, loader);\n  }\n\n  // This should not happen, all sync loaders should also offer `parse` function\n  assert(!loader.parseSync);\n\n  // TBD - If asynchronous parser not available, return null\n  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);\n}\n"],"file":"parse.js"}

package/dist/lib/api/register-loaders.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/api/register-loaders.ts"],"names":["normalizeLoader","getGlobalLoaderState","getGlobalLoaderRegistry","state","loaderRegistry","registerLoaders","loaders","Array","isArray","loader","normalizedLoader","find","registeredLoader","unshift","getRegisteredLoaders","_unregisterLoaders"],"mappings":"AACA,SAAQA,eAAR,QAA8B,kCAA9B;AACA,SAAQC,oBAAR,QAAmC,8BAAnC;;AAIA,MAAMC,uBAAuB,GAAG,MAAM;AACpC,QAAMC,KAAK,GAAGF,oBAAoB,EAAlC;AACAE,EAAAA,KAAK,CAACC,cAAN,GAAuBD,KAAK,CAACC,cAAN,IAAwB,EAA/C;AACA,SAAOD,KAAK,CAACC,cAAb;AACD,CAJD;;AAOA,OAAO,SAASC,eAAT,CAAyBC,OAAzB,EAA4C;AACjD,QAAMF,cAAc,GAAGF,uBAAuB,EAA9C;AAEAI,EAAAA,OAAO,GAAGC,KAAK,CAACC,OAAN,CAAcF,OAAd,IAAyBA,OAAzB,GAAmC,CAACA,OAAD,CAA7C;;AAEA,OAAK,MAAMG,MAAX,IAAqBH,OAArB,EAA8B;AAC5B,UAAMI,gBAAgB,GAAGV,eAAe,CAACS,MAAD,CAAxC;;AACA,QAAI,CAACL,cAAc,CAACO,IAAf,CAAqBC,gBAAD,IAAsBF,gBAAgB,KAAKE,gBAA/D,CAAL,EAAuF;AAErFR,MAAAA,cAAc,CAACS,OAAf,CAAuBH,gBAAvB;AACD;AACF;AACF;AAED,OAAO,SAASI,oBAAT,GAA0C;AAC/C,SAAOZ,uBAAuB,EAA9B;AACD;AAGD,OAAO,SAASa,kBAAT,GAA8B;AACnC,QAAMZ,KAAK,GAAGF,oBAAoB,EAAlC;AACAE,EAAAA,KAAK,CAACC,cAAN,GAAuB,EAAvB;AACD","sourcesContent":["import {Loader} from '@loaders.gl/loader-utils';\nimport {normalizeLoader} from '../loader-utils/normalize-loader';\nimport {getGlobalLoaderState} from '../loader-utils/option-utils';\n\n// Store global registered loaders on the global object to increase chances of cross loaders-version interoperability\n// This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks\nconst getGlobalLoaderRegistry = () => {\n  const state = getGlobalLoaderState();\n  state.loaderRegistry = state.loaderRegistry || [];\n  return state.loaderRegistry;\n};\n\n/** Register a list of global loaders */\nexport function registerLoaders(loaders: Loader[]) {\n  const loaderRegistry = getGlobalLoaderRegistry();\n\n  loaders = Array.isArray(loaders) ? loaders : [loaders];\n\n  for (const loader of loaders) {\n    const normalizedLoader = normalizeLoader(loader);\n    if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {\n      // add to the beginning of the loaderRegistry, so the last registeredLoader get picked\n      loaderRegistry.unshift(normalizedLoader);\n    }\n  }\n}\n\nexport function getRegisteredLoaders(): Loader[] {\n  return getGlobalLoaderRegistry();\n}\n\n/** @deprecated For testing only  */\nexport function _unregisterLoaders() {\n  const state = getGlobalLoaderState();\n  state.loaderRegistry = [];\n}\n"],"file":"register-loaders.js"}

package/dist/lib/api/save.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/api/save.ts"],"names":["encode","encodeSync","writeFile","writeFileSync","save","data","url","writer","options","encodedData","saveSync"],"mappings":"AACA,SAAQA,MAAR,EAAgBC,UAAhB,QAAiC,UAAjC;AACA,SAAQC,SAAR,EAAmBC,aAAnB,QAAuC,qBAAvC;AAEA,OAAO,eAAeC,IAAf,CAAoBC,IAApB,EAA0BC,GAA1B,EAA+BC,MAA/B,EAA+CC,OAA/C,EAAuE;AAC5E,QAAMC,WAAW,GAAG,MAAMT,MAAM,CAACK,IAAD,EAAOE,MAAP,EAAeC,OAAf,CAAhC;AACA,SAAO,MAAMN,SAAS,CAACI,GAAD,EAAMG,WAAN,CAAtB;AACD;AAED,OAAO,SAASC,QAAT,CAAkBL,IAAlB,EAAwBC,GAAxB,EAA6BC,MAA7B,EAAqCC,OAArC,EAA8C;AACnD,QAAMC,WAAW,GAAGR,UAAU,CAACI,IAAD,EAAOE,MAAP,EAAeC,OAAf,CAA9B;AACA,SAAOL,aAAa,CAACG,GAAD,EAAMG,WAAN,CAApB;AACD","sourcesContent":["import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';\nimport {encode, encodeSync} from './encode';\nimport {writeFile, writeFileSync} from '../fetch/write-file';\n\nexport async function save(data, url, writer: Writer, options: WriterOptions) {\n  const encodedData = await encode(data, writer, options);\n  return await writeFile(url, encodedData);\n}\n\nexport function saveSync(data, url, writer, options) {\n  const encodedData = encodeSync(data, writer, options);\n  return writeFileSync(url, encodedData);\n}\n"],"file":"save.js"}

package/dist/lib/api/select-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/api/select-loader.ts"],"names":["compareArrayBuffers","path","normalizeLoader","getResourceUrlAndType","getRegisteredLoaders","isBlob","EXT_PATTERN","selectLoader","data","loaders","options","context","validHTTPResponse","loader","selectLoaderSync","nothrow","slice","arrayBuffer","Error","getNoValidLoaderMessage","Array","isArray","candidateLoaders","concat","ignoreRegisteredLoaders","push","normalizeLoaders","selectLoaderInternal","url","type","testUrl","mimeType","findLoaderByMIMEType","findLoaderByUrl","findLoaderByInitialBytes","fallbackMimeType","Response","status","message","filename","firstCharacters","getFirstCharacters","match","exec","extension","findLoaderByExtension","toLowerCase","loaderExtension","extensions","mimeTypes","includes","id","testDataAgainstText","ArrayBuffer","isView","testDataAgainstBinary","buffer","byteOffset","testText","tests","some","test","startsWith","testBinary","byteLength","magic","getMagicString","length","dataView","DataView","i","String","fromCharCode","getUint8"],"mappings":"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","sourcesContent":["import type {LoaderContext, LoaderOptions, Loader} from '@loaders.gl/loader-utils';\nimport {compareArrayBuffers, path} from '@loaders.gl/loader-utils';\nimport {normalizeLoader} from '../loader-utils/normalize-loader';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {getRegisteredLoaders} from './register-loaders';\nimport {isBlob} from '../../javascript-utils/is-type';\n\nconst EXT_PATTERN = /\\.([^.]+)$/;\n\n// TODO - Need a variant that peeks at streams for parseInBatches\n// TODO - Detect multiple matching loaders? Use heuristics to grade matches?\n// TODO - Allow apps to pass context to disambiguate between multiple matches (e.g. multiple .json formats)?\n\n/**\n * Find a loader that matches file extension and/or initial file content\n * Search the loaders array argument for a loader that matches url extension or initial data\n * Returns: a normalized loader\n * @param data data to assist\n * @param loaders\n * @param options\n * @param context used internally, applications should not provide this parameter\n */\nexport async function selectLoader(\n  data: Response | Blob | ArrayBuffer | string,\n  loaders: Loader[] | Loader = [],\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<Loader | null> {\n  if (!validHTTPResponse(data)) {\n    return null;\n  }\n\n  // First make a sync attempt, disabling exceptions\n  let loader = selectLoaderSync(data, loaders, {...options, nothrow: true}, context);\n  if (loader) {\n    return loader;\n  }\n\n  // For Blobs and Files, try to asynchronously read a small initial slice and test again with that\n  // to see if we can detect by initial content\n  if (isBlob(data)) {\n    data = await (data as Blob).slice(0, 10).arrayBuffer();\n    loader = selectLoaderSync(data, loaders, options, context);\n  }\n\n  // no loader available\n  if (!loader && !options?.nothrow) {\n    throw new Error(getNoValidLoaderMessage(data));\n  }\n\n  return loader;\n}\n\n/**\n * Find a loader that matches file extension and/or initial file content\n * Search the loaders array argument for a loader that matches url extension or initial data\n * Returns: a normalized loader\n * @param data data to assist\n * @param loaders\n * @param options\n * @param context used internally, applications should not provide this parameter\n */\nexport function selectLoaderSync(\n  data: Response | Blob | ArrayBuffer | string,\n  loaders: Loader[] | Loader = [],\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Loader | null {\n  if (!validHTTPResponse(data)) {\n    return null;\n  }\n\n  // eslint-disable-next-line complexity\n  // if only a single loader was provided (not as array), force its use\n  // TODO - Should this behavior be kept and documented?\n  if (loaders && !Array.isArray(loaders)) {\n    // TODO - remove support for legacy loaders\n    return normalizeLoader(loaders);\n  }\n\n  // Build list of candidate loaders that will be searched in order for a match\n  let candidateLoaders: Loader[] = [];\n  // First search supplied loaders\n  if (loaders) {\n    candidateLoaders = candidateLoaders.concat(loaders);\n  }\n  // Then fall back to registered loaders\n  if (!options?.ignoreRegisteredLoaders) {\n    candidateLoaders.push(...getRegisteredLoaders());\n  }\n\n  // TODO - remove support for legacy loaders\n  normalizeLoaders(candidateLoaders);\n\n  const loader = selectLoaderInternal(data, candidateLoaders, options, context);\n\n  // no loader available\n  if (!loader && !options?.nothrow) {\n    throw new Error(getNoValidLoaderMessage(data));\n  }\n\n  return loader;\n}\n\n/** Implements loaders selection logic */\nfunction selectLoaderInternal(\n  data: Response | Blob | ArrayBuffer | string,\n  loaders: Loader[],\n  options?: LoaderOptions,\n  context?: LoaderContext\n) {\n  const {url, type} = getResourceUrlAndType(data);\n\n  const testUrl = url || context?.url;\n\n  let loader: Loader | null = null;\n\n  // if options.mimeType is supplied, it takes precedence\n  if (options?.mimeType) {\n    loader = findLoaderByMIMEType(loaders, options?.mimeType);\n  }\n  // Look up loader by url\n  loader = loader || findLoaderByUrl(loaders, testUrl);\n  // Look up loader by mime type\n  loader = loader || findLoaderByMIMEType(loaders, type);\n  // Look for loader via initial bytes (Note: not always accessible (e.g. Response, stream, async iterator)\n  loader = loader || findLoaderByInitialBytes(loaders, data);\n  // Look up loader by fallback mime type\n  loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);\n\n  return loader;\n}\n\n/** Check HTTP Response */\nfunction validHTTPResponse(data: any): boolean {\n  // HANDLE HTTP status\n  if (data instanceof Response) {\n    // 204 - NO CONTENT. This handles cases where e.g. a tile server responds with 204 for a missing tile\n    if (data.status === 204) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/** Generate a helpful message to help explain why loader selection failed. */\nfunction getNoValidLoaderMessage(data): string {\n  const {url, type} = getResourceUrlAndType(data);\n\n  let message = 'No valid loader found (';\n  message += url ? `${path.filename(url)}, ` : 'no url provided, ';\n  message += `MIME type: ${type ? `\"${type}\"` : 'not provided'}, `;\n  // First characters are only accessible when called on data (string or arrayBuffer).\n  const firstCharacters: string = data ? getFirstCharacters(data) : '';\n  message += firstCharacters ? ` first bytes: \"${firstCharacters}\"` : 'first bytes: not available';\n  message += ')';\n  return message;\n}\n\nfunction normalizeLoaders(loaders: Loader[]): void {\n  for (const loader of loaders) {\n    normalizeLoader(loader);\n  }\n}\n\n// TODO - Would be nice to support http://example.com/file.glb?parameter=1\n// E.g: x = new URL('http://example.com/file.glb?load=1'; x.pathname\nfunction findLoaderByUrl(loaders: Loader[], url?: string): Loader | null {\n  // Get extension\n  const match = url && EXT_PATTERN.exec(url);\n  const extension = match && match[1];\n  return extension ? findLoaderByExtension(loaders, extension) : null;\n}\n\nfunction findLoaderByExtension(loaders: Loader[], extension: string): Loader | null {\n  extension = extension.toLowerCase();\n\n  for (const loader of loaders) {\n    for (const loaderExtension of loader.extensions) {\n      if (loaderExtension.toLowerCase() === extension) {\n        return loader;\n      }\n    }\n  }\n  return null;\n}\n\nfunction findLoaderByMIMEType(loaders, mimeType) {\n  for (const loader of loaders) {\n    if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {\n      return loader;\n    }\n\n    // Support referring to loaders using the \"unregistered tree\"\n    // https://en.wikipedia.org/wiki/Media_type#Unregistered_tree\n    if (mimeType === `application/x.${loader.id}`) {\n      return loader;\n    }\n  }\n  return null;\n}\n\nfunction findLoaderByInitialBytes(loaders, data) {\n  if (!data) {\n    return null;\n  }\n\n  for (const loader of loaders) {\n    if (typeof data === 'string') {\n      if (testDataAgainstText(data, loader)) {\n        return loader;\n      }\n    } else if (ArrayBuffer.isView(data)) {\n      // Typed Arrays can have offsets into underlying buffer\n      if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) {\n        return loader;\n      }\n    } else if (data instanceof ArrayBuffer) {\n      const byteOffset = 0;\n      if (testDataAgainstBinary(data, byteOffset, loader)) {\n        return loader;\n      }\n    }\n    // TODO Handle streaming case (requires creating a new AsyncIterator)\n  }\n  return null;\n}\n\nfunction testDataAgainstText(data, loader) {\n  if (loader.testText) {\n    return loader.testText(data);\n  }\n\n  const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];\n  return tests.some((test) => data.startsWith(test));\n}\n\nfunction testDataAgainstBinary(data, byteOffset, loader) {\n  const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];\n  return tests.some((test) => testBinary(data, byteOffset, loader, test));\n}\n\nfunction testBinary(data, byteOffset, loader, test) {\n  if (test instanceof ArrayBuffer) {\n    return compareArrayBuffers(test, data, test.byteLength);\n  }\n  switch (typeof test) {\n    case 'function':\n      return test(data, loader);\n\n    case 'string':\n      // Magic bytes check: If `test` is a string, check if binary data starts with that strings\n      const magic = getMagicString(data, byteOffset, test.length);\n      return test === magic;\n\n    default:\n      return false;\n  }\n}\n\nfunction getFirstCharacters(data, length: number = 5) {\n  if (typeof data === 'string') {\n    return data.slice(0, length);\n  } else if (ArrayBuffer.isView(data)) {\n    // Typed Arrays can have offsets into underlying buffer\n    return getMagicString(data.buffer, data.byteOffset, length);\n  } else if (data instanceof ArrayBuffer) {\n    const byteOffset = 0;\n    return getMagicString(data, byteOffset, length);\n  }\n  return '';\n}\n\nfunction getMagicString(arrayBuffer, byteOffset, length) {\n  if (arrayBuffer.byteLength < byteOffset + length) {\n    return '';\n  }\n  const dataView = new DataView(arrayBuffer);\n  let magic = '';\n  for (let i = 0; i < length; i++) {\n    magic += String.fromCharCode(dataView.getUint8(byteOffset + i));\n  }\n  return magic;\n}\n"],"file":"select-loader.js"}

package/dist/lib/api/set-loader-options.d.ts

@@ -1,6 +0,0 @@
-/**
- * Set global loader options
- * @param options
- */
-export declare function setLoaderOptions(options: object): void;
-//# sourceMappingURL=set-loader-options.d.ts.map

package/dist/lib/api/set-loader-options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set-loader-options.d.ts","sourceRoot":"","sources":["../../../src/lib/api/set-loader-options.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAEtD"}

package/dist/lib/api/set-loader-options.js

@@ -1,5 +0,0 @@
-import { setGlobalOptions } from '../loader-utils/option-utils';
-export function setLoaderOptions(options) {
-  setGlobalOptions(options);
-}
-//# sourceMappingURL=set-loader-options.js.map

package/dist/lib/api/set-loader-options.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/api/set-loader-options.ts"],"names":["setGlobalOptions","setLoaderOptions","options"],"mappings":"AAAA,SAAQA,gBAAR,QAA+B,8BAA/B;AAMA,OAAO,SAASC,gBAAT,CAA0BC,OAA1B,EAAiD;AACtDF,EAAAA,gBAAgB,CAACE,OAAD,CAAhB;AACD","sourcesContent":["import {setGlobalOptions} from '../loader-utils/option-utils';\n\n/**\n * Set global loader options\n * @param options\n */\nexport function setLoaderOptions(options: object): void {\n  setGlobalOptions(options);\n}\n"],"file":"set-loader-options.js"}

package/dist/lib/common.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"common.js"}

package/dist/lib/fetch/fetch-error-message.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/fetch/fetch-error-message.ts"],"names":["getErrorMessageFromResponseSync","response","url","status","statusText","getErrorMessageFromResponse","message","contentType","headers","get","includes","text","error"],"mappings":"AAAA,OAAO,SAASA,+BAAT,CAAyCC,QAAzC,EAAqE;AAC1E,4CAAmCA,QAAQ,CAACC,GAA5C,cAAmDD,QAAQ,CAACE,MAA5D,gBAAwEF,QAAQ,CAACG,UAAjF;AACD;AAED,OAAO,eAAeC,2BAAf,CAA2CJ,QAA3C,EAAgF;AACrF,MAAIK,OAAO,sCAA+BL,QAAQ,CAACC,GAAxC,eAAgDD,QAAQ,CAACE,MAAzD,QAAX;;AACA,MAAI;AACF,UAAMI,WAAW,GAAGN,QAAQ,CAACO,OAAT,CAAiBC,GAAjB,CAAqB,cAArB,KAAwC,EAA5D;;AACA,QAAIF,WAAW,CAACG,QAAZ,CAAqB,kBAArB,CAAJ,EAA8C;AAC5CJ,MAAAA,OAAO,IAAI,MAAML,QAAQ,CAACU,IAAT,EAAjB;AACD,KAFD,MAEO;AACLL,MAAAA,OAAO,IAAIL,QAAQ,CAACG,UAApB;AACD;AACF,GAPD,CAOE,OAAOQ,KAAP,EAAc;AAEd,WAAON,OAAP;AACD;;AACD,SAAOA,OAAP;AACD","sourcesContent":["export function getErrorMessageFromResponseSync(response: Response): string {\n  return `Failed to fetch resource ${response.url}(${response.status}): ${response.statusText} `;\n}\n\nexport async function getErrorMessageFromResponse(response: Response): Promise<string> {\n  let message = `Failed to fetch resource ${response.url} (${response.status}): `;\n  try {\n    const contentType = response.headers.get('Content-Type') || '';\n    if (contentType.includes('application/json')) {\n      message += await response.text();\n    } else {\n      message += response.statusText;\n    }\n  } catch (error) {\n    // eslint forbids return in finally statement\n    return message;\n  }\n  return message;\n}\n"],"file":"fetch-error-message.js"}

package/dist/lib/fetch/fetch-file.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/fetch/fetch-file.ts"],"names":["resolvePath","makeResponse","fetchFile","url","options","fetchOptions","fetch"],"mappings":"AAAA,SAAQA,WAAR,QAA0B,0BAA1B;AACA,SAAQC,YAAR,QAA2B,yBAA3B;AAYA,OAAO,eAAeC,SAAf,CACLC,GADK,EAELC,OAFK,EAGc;AACnB,MAAI,OAAOD,GAAP,KAAe,QAAnB,EAA6B;AAC3BA,IAAAA,GAAG,GAAGH,WAAW,CAACG,GAAD,CAAjB;AAEA,QAAIE,YAAyB,GAAGD,OAAhC;;AACA,QAAIA,OAAO,SAAP,IAAAA,OAAO,WAAP,IAAAA,OAAO,CAAEE,KAAT,IAAkB,QAAOF,OAAP,aAAOA,OAAP,uBAAOA,OAAO,CAAEE,KAAhB,MAA0B,UAAhD,EAA4D;AAC1DD,MAAAA,YAAY,GAAGD,OAAO,CAACE,KAAvB;AACD;;AAED,WAAO,MAAMA,KAAK,CAACH,GAAD,EAAME,YAAN,CAAlB;AACD;;AAED,SAAO,MAAMJ,YAAY,CAACE,GAAD,CAAzB;AACD","sourcesContent":["import {resolvePath} from '@loaders.gl/loader-utils';\nimport {makeResponse} from '../utils/response-utils';\n// import {getErrorMessageFromResponse} from './fetch-error-message';\n\n/**\n * fetch compatible function\n * Reads file data from:\n * - http/http urls\n * - data urls\n * - File/Blob objects\n * Leverages `@loaders.gl/polyfills` for Node.js support\n * Respects pathPrefix and file aliases\n */\nexport async function fetchFile(\n  url: string | Blob,\n  options?: RequestInit & {fetch?: RequestInit | Function}\n): Promise<Response> {\n  if (typeof url === 'string') {\n    url = resolvePath(url);\n\n    let fetchOptions: RequestInit = options as RequestInit;\n    if (options?.fetch && typeof options?.fetch !== 'function') {\n      fetchOptions = options.fetch;\n    }\n\n    return await fetch(url, fetchOptions);\n  }\n\n  return await makeResponse(url);\n}\n"],"file":"fetch-file.js"}

package/dist/lib/fetch/read-array-buffer.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/fetch/read-array-buffer.ts"],"names":["fs","readArrayBuffer","file","start","length","_readToArrayBuffer","Blob","slice","readBlob","blob","Promise","resolve","reject","fileReader","FileReader","onload","event","target","result","onerror","error","readAsArrayBuffer"],"mappings":"AACA,SAAQA,EAAR,QAAiB,0BAAjB;AASA,OAAO,eAAeC,eAAf,CACLC,IADK,EAELC,KAFK,EAGLC,MAHK,EAIiB;AACtB,MAAI,OAAOF,IAAP,KAAgB,QAApB,EAA8B;AAC5B,WAAO,MAAMF,EAAE,CAACK,kBAAH,CAAsBH,IAAtB,EAA4BC,KAA5B,EAAmCC,MAAnC,CAAb;AACD;;AAED,MAAI,EAAEF,IAAI,YAAYI,IAAlB,CAAJ,EAA6B;AAC3BJ,IAAAA,IAAI,GAAG,IAAII,IAAJ,CAAS,CAACJ,IAAD,CAAT,CAAP;AACD;;AACD,QAAMK,KAAK,GAAGL,IAAI,CAACK,KAAL,CAAWJ,KAAX,EAAkBA,KAAK,GAAGC,MAA1B,CAAd;AACA,SAAO,MAAMI,QAAQ,CAACD,KAAD,CAArB;AACD;AASD,OAAO,eAAeC,QAAf,CAAwBC,IAAxB,EAA0D;AAC/D,SAAO,MAAM,IAAIC,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;AAC5C,UAAMC,UAAU,GAAG,IAAIC,UAAJ,EAAnB;;AACAD,IAAAA,UAAU,CAACE,MAAX,GAAqBC,KAAD;AAAA;;AAAA,aAClBL,OAAO,CAACK,KAAD,aAACA,KAAD,wCAACA,KAAK,CAAEC,MAAR,kDAAC,cAAeC,MAAhB,CADW;AAAA,KAApB;;AAGAL,IAAAA,UAAU,CAACM,OAAX,GAAsBC,KAAD,IAAsCR,MAAM,CAACQ,KAAD,CAAjE;;AACAP,IAAAA,UAAU,CAACQ,iBAAX,CAA6BZ,IAA7B;AACD,GAPY,CAAb;AAQD","sourcesContent":["//\nimport {fs} from '@loaders.gl/loader-utils';\n\n/**\n * Reads a chunk from a random access file\n * @param file\n * @param start\n * @param length\n * @returns\n */\nexport async function readArrayBuffer(\n  file: Blob | ArrayBuffer | string | number,\n  start: number,\n  length: number\n): Promise<ArrayBuffer> {\n  if (typeof file === 'number') {\n    return await fs._readToArrayBuffer(file, start, length);\n  }\n  // TODO - we can do better for ArrayBuffer and string\n  if (!(file instanceof Blob)) {\n    file = new Blob([file]);\n  }\n  const slice = file.slice(start, start + length);\n  return await readBlob(slice);\n}\n\n/**\n * Read a slice of a Blob or File, without loading the entire file into memory\n * The trick when reading File objects is to read successive \"slices\" of the File\n * Per spec https://w3c.github.io/FileAPI/, slicing a File only updates the start and end fields\n * Actually reading from file happens in `readAsArrayBuffer`\n * @param blob to read\n */\nexport async function readBlob(blob: Blob): Promise<ArrayBuffer> {\n  return await new Promise((resolve, reject) => {\n    const fileReader = new FileReader();\n    fileReader.onload = (event: ProgressEvent<FileReader>) =>\n      resolve(event?.target?.result as ArrayBuffer);\n    // TODO - reject with a proper Error\n    fileReader.onerror = (error: ProgressEvent<FileReader>) => reject(error);\n    fileReader.readAsArrayBuffer(blob);\n  });\n}\n"],"file":"read-array-buffer.js"}

package/dist/lib/fetch/read-file.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/fetch/read-file.ts"],"names":["isBrowser","resolvePath","fs","toArrayBuffer","assert","readFileSync","url","options","buffer","nothrow"],"mappings":"AACA,SAAQA,SAAR,EAAmBC,WAAnB,EAAgCC,EAAhC,EAAoCC,aAApC,QAAwD,0BAAxD;AACA,SAAQC,MAAR,QAAqB,0BAArB;AAQA,OAAO,SAASC,YAAT,CAAsBC,GAAtB,EAAmCC,OAAe,GAAG,EAArD,EAAyD;AAC9DD,EAAAA,GAAG,GAAGL,WAAW,CAACK,GAAD,CAAjB;;AAOA,MAAI,CAACN,SAAL,EAAgB;AACd,UAAMQ,MAAM,GAAGN,EAAE,CAACG,YAAH,CAAgBC,GAAhB,EAAqBC,OAArB,CAAf;AACA,WAAO,OAAOC,MAAP,KAAkB,QAAlB,GAA6BL,aAAa,CAACK,MAAD,CAA1C,GAAqDA,MAA5D;AACD;;AAGD,MAAI,CAACD,OAAO,CAACE,OAAb,EAAsB;AAEpBL,IAAAA,MAAM,CAAC,KAAD,CAAN;AACD;;AAED,SAAO,IAAP;AACD","sourcesContent":["// File read\nimport {isBrowser, resolvePath, fs, toArrayBuffer} from '@loaders.gl/loader-utils';\nimport {assert} from '@loaders.gl/loader-utils';\n\n// TODO - this is not tested\n// const isDataURL = (url) => url.startsWith('data:');\n\n/**\n * In a few cases (data URIs, node.js) \"files\" can be read synchronously\n */\nexport function readFileSync(url: string, options: object = {}) {\n  url = resolvePath(url);\n\n  // Only support this if we can also support sync data URL decoding in browser\n  // if (isDataURL(url)) {\n  //   return decodeDataUri(url);\n  // }\n\n  if (!isBrowser) {\n    const buffer = fs.readFileSync(url, options);\n    return typeof buffer !== 'string' ? toArrayBuffer(buffer) : buffer;\n  }\n\n  // @ts-ignore\n  if (!options.nothrow) {\n    // throw new Error('Cant load URI synchronously');\n    assert(false);\n  }\n\n  return null;\n}\n"],"file":"read-file.js"}

package/dist/lib/fetch/write-file.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/fetch/write-file.ts"],"names":["isBrowser","assert","resolvePath","fs","toBuffer","writeFile","filePath","arrayBufferOrString","options","flag","writeFileSync"],"mappings":"AACA,SAAQA,SAAR,EAAmBC,MAAnB,EAA2BC,WAA3B,QAA6C,0BAA7C;AACA,SAAQC,EAAR,EAAYC,QAAZ,QAA2B,0BAA3B;AAEA,OAAO,eAAeC,SAAf,CACLC,QADK,EAELC,mBAFK,EAGLC,OAHK,EAIU;AACfF,EAAAA,QAAQ,GAAGJ,WAAW,CAACI,QAAD,CAAtB;;AACA,MAAI,CAACN,SAAL,EAAgB;AACd,UAAMG,EAAE,CAACE,SAAH,CAAaC,QAAb,EAAuBF,QAAQ,CAACG,mBAAD,CAA/B,EAAsD;AAACE,MAAAA,IAAI,EAAE;AAAP,KAAtD,CAAN;AACD;;AACDR,EAAAA,MAAM,CAAC,KAAD,CAAN;AACD;AAED,OAAO,SAASS,aAAT,CACLJ,QADK,EAELC,mBAFK,EAGLC,OAHK,EAIC;AACNF,EAAAA,QAAQ,GAAGJ,WAAW,CAACI,QAAD,CAAtB;;AACA,MAAI,CAACN,SAAL,EAAgB;AACdG,IAAAA,EAAE,CAACO,aAAH,CAAiBJ,QAAjB,EAA2BF,QAAQ,CAACG,mBAAD,CAAnC,EAA0D;AAACE,MAAAA,IAAI,EAAE;AAAP,KAA1D;AACD;;AACDR,EAAAA,MAAM,CAAC,KAAD,CAAN;AACD","sourcesContent":["// file write\nimport {isBrowser, assert, resolvePath} from '@loaders.gl/loader-utils';\nimport {fs, toBuffer} from '@loaders.gl/loader-utils';\n\nexport async function writeFile(\n  filePath: string,\n  arrayBufferOrString: ArrayBuffer | string,\n  options?\n): Promise<void> {\n  filePath = resolvePath(filePath);\n  if (!isBrowser) {\n    await fs.writeFile(filePath, toBuffer(arrayBufferOrString), {flag: 'w'});\n  }\n  assert(false);\n}\n\nexport function writeFileSync(\n  filePath: string,\n  arrayBufferOrString: ArrayBuffer | string,\n  options?\n): void {\n  filePath = resolvePath(filePath);\n  if (!isBrowser) {\n    fs.writeFileSync(filePath, toBuffer(arrayBufferOrString), {flag: 'w'});\n  }\n  assert(false);\n}\n"],"file":"write-file.js"}

package/dist/lib/filesystems/browser-filesystem.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/filesystems/browser-filesystem.ts"],"names":["BrowserFileSystem","constructor","files","options","_fetch","fetch","i","length","file","name","lowerCaseFiles","toLowerCase","usedFiles","bind","path","includes","Response","status","statusText","headers","Headers","range","get","bytes","exec","start","parseInt","end","data","slice","arrayBuffer","response","Object","defineProperty","value","readdir","dirname","push","stat","Error","size","unlink","open","pathname","flags","mode","read","fd","buffer","offset","byteLength","position","startPosition","bytesRead","close","_getFile","used"],"mappings":"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","sourcesContent":["import type {FileSystem} from './filesystem';\n\ntype BrowserFileSystemOptions = {\n  fetch?: typeof fetch;\n};\n\n/**\n * FileSystem adapter for a browser FileList.\n * Holds a list of browser 'File' objects.\n */\nexport default class BrowserFileSystem implements FileSystem {\n  private _fetch: typeof fetch;\n  private files: {[filename: string]: File} = {};\n  private lowerCaseFiles: {[filename: string]: File} = {};\n  private usedFiles: {[filename: string]: boolean} = {};\n\n  /**\n   * A FileSystem API wrapper around a list of browser 'File' objects\n   * @param files\n   * @param options\n   */\n  constructor(files: FileList | File[], options?: BrowserFileSystemOptions) {\n    this._fetch = options?.fetch || fetch;\n\n    for (let i = 0; i < files.length; ++i) {\n      const file = files[i];\n      this.files[file.name] = file;\n      this.lowerCaseFiles[file.name.toLowerCase()] = file;\n      this.usedFiles[file.name] = false;\n    }\n\n    this.fetch = this.fetch.bind(this);\n  }\n\n  // implements IFileSystem\n\n  /**\n   * Implementation of fetch against this file system\n   * Delegates to global fetch for http{s}:// or data://\n   */\n  async fetch(path: string, options?: RequestInit): Promise<Response> {\n    // Fallback to handle https:/http:/data: etc fetches\n    if (path.includes('://')) {\n      return this._fetch(path, options);\n    }\n\n    // Local fetches are served from the list of files\n    const file = this.files[path];\n    if (!file) {\n      return new Response(path, {status: 400, statusText: 'NOT FOUND'});\n    }\n\n    const headers = new Headers(options?.headers);\n    const range = headers.get('Range');\n    const bytes = range && /bytes=($1)-($2)/.exec(range);\n\n    if (bytes) {\n      const start = parseInt(bytes[1]);\n      const end = parseInt(bytes[2]);\n      // The trick when reading File objects is to read successive \"slices\" of the File\n      // Per spec https://w3c.github.io/FileAPI/, slicing a File should only update the start and end fields\n      // Actually reading from file should happen in `readAsArrayBuffer` (and as far we can tell it does)\n      const data = await file.slice(start, end).arrayBuffer();\n      const response = new Response(data);\n      Object.defineProperty(response, 'url', {value: path});\n      return response;\n    }\n\n    // return makeResponse()\n    const response = new Response(file);\n    Object.defineProperty(response, 'url', {value: path});\n    return response;\n  }\n\n  /**\n   * List filenames in this filesystem\n   * @param dirname\n   * @returns\n   */\n  async readdir(dirname?: string): Promise<string[]> {\n    const files: string[] = [];\n    for (const path in this.files) {\n      files.push(path);\n    }\n    // TODO filter by dirname\n    return files;\n  }\n\n  /**\n   * Return information (size) about files in this file system\n   */\n  async stat(path: string, options?: object): Promise<{size: number}> {\n    const file = this.files[path];\n    if (!file) {\n      throw new Error(path);\n    }\n    return {size: file.size};\n  }\n\n  /**\n   * Just removes the file from the list\n   */\n  async unlink(path: string): Promise<void> {\n    delete this.files[path];\n    delete this.lowerCaseFiles[path];\n    this.usedFiles[path] = true;\n  }\n\n  // implements IRandomAccessFileSystem\n\n  // RANDOM ACCESS\n  async open(pathname: string, flags, mode?): Promise<any> {\n    return this.files[pathname];\n  }\n\n  /**\n   * Read a range into a buffer\n   * @todo - handle position memory\n   * @param buffer is the buffer that the data (read from the fd) will be written to.\n   * @param offset is the offset in the buffer to start writing at.\n   * @param length is an integer specifying the number of bytes to read.\n   * @param position is an argument specifying where to begin reading from in the file. If position is null, data will be read from the current file position, and the file position will be updated. If position is an integer, the file position will remain unchanged.\n   */\n  async read(\n    fd: any,\n    buffer: ArrayBuffer,\n    offset: number = 0,\n    length: number = buffer.byteLength,\n    position: number | null = null\n  ): Promise<{bytesRead: number; buffer: ArrayBuffer}> {\n    const file = fd as File;\n    const startPosition = 0; // position\n    const arrayBuffer = await file.slice(startPosition, startPosition + length).arrayBuffer();\n    // copy into target buffer\n    return {bytesRead: length, buffer: arrayBuffer};\n  }\n\n  async close(fd: number): Promise<void> {\n    // NO OP\n  }\n\n  // fstat(fd: number): Promise<object>; // Stat\n\n  // PRIVATE\n\n  // Supports case independent paths, and file usage tracking\n  _getFile(path, used) {\n    // Prefer case match, but fall back to case indepent.\n    const file = this.files[path] || this.lowerCaseFiles[path];\n    if (file && used) {\n      this.usedFiles[path] = true;\n    }\n    return file;\n  }\n}\n"],"file":"browser-filesystem.js"}

package/dist/lib/filesystems/filesystem.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"filesystem.js"}

package/dist/lib/filesystems/read-array-buffer.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/filesystems/read-array-buffer.ts"],"names":["readArrayBuffer","file","start","length","Blob","slice","arrayBuffer","read"],"mappings":"AAEA,OAAO,eAAeA,eAAf,CACLC,IADK,EAELC,KAFK,EAGLC,MAHK,EAIiB;AACtB,MAAIF,IAAI,YAAYG,IAApB,EAA0B;AACxB,UAAMC,KAAK,GAAGJ,IAAI,CAACI,KAAL,CAAWH,KAAX,EAAkBA,KAAK,GAAGC,MAA1B,CAAd;AACA,WAAO,MAAME,KAAK,CAACC,WAAN,EAAb;AACD;;AACD,SAAO,MAAML,IAAI,CAACM,IAAL,CAAUL,KAAV,EAAiBA,KAAK,GAAGC,MAAzB,CAAb;AACD","sourcesContent":["// Random-Access read\n\nexport async function readArrayBuffer(\n  file: Blob | ArrayBuffer | any,\n  start: number,\n  length: number\n): Promise<ArrayBuffer> {\n  if (file instanceof Blob) {\n    const slice = file.slice(start, start + length);\n    return await slice.arrayBuffer();\n  }\n  return await file.read(start, start + length);\n}\n\n/**\n * Read a slice of a Blob or File, without loading the entire file into memory\n * The trick when reading File objects is to read successive \"slices\" of the File\n * Per spec https://w3c.github.io/FileAPI/, slicing a File only updates the start and end fields\n * Actually reading from file happens in `readAsArrayBuffer`\n * @param blob to read\n export async function readBlob(blob: Blob): Promise<ArrayBuffer> {\n  return await new Promise((resolve, reject) => {\n    const fileReader = new FileReader();\n    fileReader.onload = (event: ProgressEvent<FileReader>) =>\n      resolve(event?.target?.result as ArrayBuffer);\n    // TODO - reject with a proper Error\n    fileReader.onerror = (error: ProgressEvent<FileReader>) => reject(error);\n    fileReader.readAsArrayBuffer(blob);\n  });\n}\n*/\n"],"file":"read-array-buffer.js"}

package/dist/lib/init.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/lib/init.ts"],"names":["version","globalThis","loaders","Object","assign","VERSION"],"mappings":"AACA,MAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,EAAnE;AAGAC,UAAU,CAACC,OAAX,GAAqBC,MAAM,CAACC,MAAP,CAAcH,UAAU,CAACC,OAAX,IAAsB,EAApC,EAAwC;AAC3DG,EAAAA,OAAO,EAAEL;AADkD,CAAxC,CAArB;AAKA,eAAeC,UAAU,CAACC,OAA1B","sourcesContent":["// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst version = typeof __VERSION__ !== 'undefined' ? __VERSION__ : '';\n\n// @ts-ignore\nglobalThis.loaders = Object.assign(globalThis.loaders || {}, {\n  VERSION: version\n});\n\n// @ts-ignore\nexport default globalThis.loaders;\n"],"file":"init.js"}

package/dist/lib/loader-utils/check-errors.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/loader-utils/check-errors.ts"],"names":["checkFetchResponseStatus","response","ok","errorMessage","status","statusText","text","getErrorText","error","Error","checkFetchResponseStatusSync","matches","match","slice"],"mappings":"AAAA,OAAO,eAAeA,wBAAf,CAAwCC,QAAxC,EAAkD;AACvD,MAAI,CAACA,QAAQ,CAACC,EAAd,EAAkB;AAChB,QAAIC,YAAY,0BAAmBF,QAAQ,CAACG,MAA5B,cAAsCH,QAAQ,CAACI,UAA/C,CAAhB;;AACA,QAAI;AACF,YAAMC,IAAI,GAAG,MAAML,QAAQ,CAACK,IAAT,EAAnB;;AACA,UAAIA,IAAJ,EAAU;AACRH,QAAAA,YAAY,gBAASI,YAAY,CAACD,IAAD,CAArB,CAAZ;AACD;AACF,KALD,CAKE,OAAOE,KAAP,EAAc,CAEf;;AACD,UAAM,IAAIC,KAAJ,CAAUN,YAAV,CAAN;AACD;AACF;AAED,OAAO,SAASO,4BAAT,CAAsCT,QAAtC,EAAgD;AACrD,MAAI,CAACA,QAAQ,CAACC,EAAd,EAAkB;AAChB,UAAM,IAAIO,KAAJ,wBAA0BR,QAAQ,CAACG,MAAnC,EAAN;AACD;AACF;;AAED,SAASG,YAAT,CAAsBD,IAAtB,EAA4B;AAE1B,QAAMK,OAAO,GAAGL,IAAI,CAACM,KAAL,CAAW,iBAAX,CAAhB;AACA,SAAOD,OAAO,GAAGA,OAAO,CAAC,CAAD,CAAV,cAAoBL,IAAI,CAACO,KAAL,CAAW,CAAX,EAAc,EAAd,CAApB,QAAd;AACD","sourcesContent":["export async function checkFetchResponseStatus(response) {\n  if (!response.ok) {\n    let errorMessage = `fetch failed ${response.status} ${response.statusText}`;\n    try {\n      const text = await response.text();\n      if (text) {\n        errorMessage += `: ${getErrorText(text)}`;\n      }\n    } catch (error) {\n      // ignore error\n    }\n    throw new Error(errorMessage);\n  }\n}\n\nexport function checkFetchResponseStatusSync(response) {\n  if (!response.ok) {\n    throw new Error(`fetch failed ${response.status}`);\n  }\n}\n\nfunction getErrorText(text) {\n  // Look for HTML error texts\n  const matches = text.match('<pre>(.*)</pre>');\n  return matches ? matches[1] : ` ${text.slice(0, 10)}...`;\n}\n"],"file":"check-errors.js"}

package/dist/lib/loader-utils/get-data.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/loader-utils/get-data.ts"],"names":["concatenateArrayBuffersAsync","isResponse","isReadableStream","isAsyncIterable","isIterable","isIterator","isBlob","isBuffer","makeIterator","checkResponse","makeResponse","ERR_DATA","getArrayBufferOrStringFromDataSync","data","loader","options","text","buffer","ArrayBuffer","arrayBuffer","binary","textDecoder","TextDecoder","decode","isView","byteLength","length","byteOffset","slice","Error","getArrayBufferOrStringFromData","isArrayBuffer","response","getAsyncIterableFromData","body","Symbol","asyncIterator","getIterableFromData","getReadableStream","oneChunk","iterator"],"mappings":"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","sourcesContent":["import type {\n  DataType,\n  SyncDataType,\n  BatchableDataType,\n  Loader,\n  LoaderOptions\n} from '@loaders.gl/loader-utils';\nimport {concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\nimport {\n  isResponse,\n  isReadableStream,\n  isAsyncIterable,\n  isIterable,\n  isIterator,\n  isBlob,\n  isBuffer\n} from '../../javascript-utils/is-type';\nimport {makeIterator} from '../../iterators/make-iterator/make-iterator';\nimport {checkResponse, makeResponse} from '../utils/response-utils';\n\nconst ERR_DATA = 'Cannot convert supplied data type';\n\n// eslint-disable-next-line complexity\nexport function getArrayBufferOrStringFromDataSync(\n  data: SyncDataType,\n  loader: Loader,\n  options: LoaderOptions\n): ArrayBuffer | string {\n  if (loader.text && typeof data === 'string') {\n    return data;\n  }\n\n  if (isBuffer(data)) {\n    // @ts-ignore\n    data = data.buffer;\n  }\n\n  if (data instanceof ArrayBuffer) {\n    const arrayBuffer = data;\n    if (loader.text && !loader.binary) {\n      const textDecoder = new TextDecoder('utf8');\n      return textDecoder.decode(arrayBuffer);\n    }\n    return arrayBuffer;\n  }\n\n  // We may need to handle offsets\n  if (ArrayBuffer.isView(data)) {\n    // TextDecoder is invoked on typed arrays and will handle offsets\n    if (loader.text && !loader.binary) {\n      const textDecoder = new TextDecoder('utf8');\n      return textDecoder.decode(data);\n    }\n\n    let arrayBuffer = data.buffer;\n\n    // Since we are returning the underlying arrayBuffer, we must create a new copy\n    // if this typed array / Buffer is a partial view into the ArryayBuffer\n    // TODO - this is a potentially unnecessary copy\n    const byteLength = data.byteLength || data.length;\n    if (data.byteOffset !== 0 || byteLength !== arrayBuffer.byteLength) {\n      // console.warn(`loaders.gl copying arraybuffer of length ${byteLength}`);\n      arrayBuffer = arrayBuffer.slice(data.byteOffset, data.byteOffset + byteLength);\n    }\n    return arrayBuffer;\n  }\n\n  throw new Error(ERR_DATA);\n}\n\n// Convert async iterator to a promise\nexport async function getArrayBufferOrStringFromData(\n  data: DataType,\n  loader: Loader,\n  options: LoaderOptions\n): Promise<ArrayBuffer | string> {\n  const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);\n  if (typeof data === 'string' || isArrayBuffer) {\n    return getArrayBufferOrStringFromDataSync(data as string | ArrayBuffer, loader, options);\n  }\n\n  // Blobs and files are FileReader compatible\n  if (isBlob(data)) {\n    data = await makeResponse(data);\n  }\n\n  if (isResponse(data)) {\n    const response = data as Response;\n    await checkResponse(response);\n    return loader.binary ? await response.arrayBuffer() : await response.text();\n  }\n\n  if (isReadableStream(data)) {\n    // @ts-expect-error TS2559 options type\n    data = makeIterator(data as ReadableStream, options);\n  }\n\n  if (isIterable(data) || isAsyncIterable(data)) {\n    // Assume arrayBuffer iterator - attempt to concatenate\n    return concatenateArrayBuffersAsync(data as AsyncIterable<ArrayBuffer>);\n  }\n\n  throw new Error(ERR_DATA);\n}\n\nexport async function getAsyncIterableFromData(\n  data: BatchableDataType,\n  options: LoaderOptions\n): Promise<AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>> {\n  if (isIterator(data)) {\n    return data as AsyncIterable<ArrayBuffer>;\n  }\n\n  if (isResponse(data)) {\n    const response = data as Response;\n    // Note Since this function is not async, we currently can't load error message, just status\n    await checkResponse(response);\n    // TODO - bug in polyfill, body can be a Promise under Node.js\n    // eslint-disable-next-line @typescript-eslint/await-thenable\n    const body = await response.body;\n    // TODO - body can be null?\n    return makeIterator(body as ReadableStream<Uint8Array>, options as any);\n  }\n\n  if (isBlob(data) || isReadableStream(data)) {\n    return makeIterator(data as Blob | ReadableStream, options as any);\n  }\n\n  if (isAsyncIterable(data)) {\n    return data[Symbol.asyncIterator]();\n  }\n\n  return getIterableFromData(data);\n}\n\nexport async function getReadableStream(data: BatchableDataType): Promise<ReadableStream> {\n  if (isReadableStream(data)) {\n    return data as ReadableStream;\n  }\n  if (isResponse(data)) {\n    // @ts-ignore\n    return data.body;\n  }\n  const response = await makeResponse(data);\n  // @ts-ignore\n  return response.body;\n}\n\n// HELPERS\n\nfunction getIterableFromData(data) {\n  // generate an iterator that emits a single chunk\n  if (ArrayBuffer.isView(data)) {\n    return (function* oneChunk() {\n      yield data.buffer;\n    })();\n  }\n\n  if (data instanceof ArrayBuffer) {\n    return (function* oneChunk() {\n      yield data;\n    })();\n  }\n\n  if (isIterator(data)) {\n    return data;\n  }\n\n  if (isIterable(data)) {\n    return data[Symbol.iterator]();\n  }\n\n  throw new Error(ERR_DATA);\n}\n"],"file":"get-data.js"}

package/dist/lib/loader-utils/loader-context.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/loader-utils/loader-context.ts"],"names":["getFetchFunction","getLoaderContext","context","options","previousContext","resolvedContext","fetch","Array","isArray","loaders","getLoadersFromContext","candidateLoaders","contextLoaders","length"],"mappings":"AACA,SAAQA,gBAAR,QAA+B,gBAA/B;AAWA,OAAO,SAASC,gBAAT,CACLC,OADK,EAELC,OAFK,EAGLC,eAAqC,GAAG,IAHnC,EAIU;AAGf,MAAIA,eAAJ,EAAqB;AACnB,WAAOA,eAAP;AACD;;AAED,QAAMC,eAA8B,GAAG;AACrCC,IAAAA,KAAK,EAAEN,gBAAgB,CAACG,OAAD,EAAUD,OAAV,CADc;AAErC,OAAGA;AAFkC,GAAvC;;AAMA,MAAI,CAACK,KAAK,CAACC,OAAN,CAAcH,eAAe,CAACI,OAA9B,CAAL,EAA6C;AAC3CJ,IAAAA,eAAe,CAACI,OAAhB,GAA0B,IAA1B;AACD;;AAED,SAAOJ,eAAP;AACD;AAGD,OAAO,SAASK,qBAAT,CACLD,OADK,EAELP,OAFK,EAGL;AAEA,MAAI,CAACA,OAAD,IAAYO,OAAZ,IAAuB,CAACF,KAAK,CAACC,OAAN,CAAcC,OAAd,CAA5B,EAAoD;AAClD,WAAOA,OAAP;AACD;;AAGD,MAAIE,gBAAJ;;AACA,MAAIF,OAAJ,EAAa;AACXE,IAAAA,gBAAgB,GAAGJ,KAAK,CAACC,OAAN,CAAcC,OAAd,IAAyBA,OAAzB,GAAmC,CAACA,OAAD,CAAtD;AACD;;AACD,MAAIP,OAAO,IAAIA,OAAO,CAACO,OAAvB,EAAgC;AAC9B,UAAMG,cAAc,GAAGL,KAAK,CAACC,OAAN,CAAcN,OAAO,CAACO,OAAtB,IAAiCP,OAAO,CAACO,OAAzC,GAAmD,CAACP,OAAO,CAACO,OAAT,CAA1E;AACAE,IAAAA,gBAAgB,GAAGA,gBAAgB,GAAG,CAAC,GAAGA,gBAAJ,EAAsB,GAAGC,cAAzB,CAAH,GAA8CA,cAAjF;AACD;;AAED,SAAOD,gBAAgB,IAAIA,gBAAgB,CAACE,MAArC,GAA8CF,gBAA9C,GAAiE,IAAxE;AACD","sourcesContent":["import type {Loader, LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';\nimport {getFetchFunction} from './option-utils';\n\n/**\n * \"sub\" loaders invoked by other loaders get a \"context\" injected on `this`\n * The context will inject core methods like `parse` and contain information\n * about loaders and options passed in to the top-level `parse` call.\n *\n * @param context\n * @param options\n * @param previousContext\n */\nexport function getLoaderContext(\n  context: Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>,\n  options?: LoaderOptions,\n  previousContext: LoaderContext | null = null\n): LoaderContext {\n  // For recursive calls, we already have a context\n  // TODO - add any additional loaders to context?\n  if (previousContext) {\n    return previousContext;\n  }\n\n  const resolvedContext: LoaderContext = {\n    fetch: getFetchFunction(options, context),\n    ...context\n  };\n\n  // Recursive loading does not use single loader\n  if (!Array.isArray(resolvedContext.loaders)) {\n    resolvedContext.loaders = null;\n  }\n\n  return resolvedContext;\n}\n\n// eslint-disable-next-line complexity\nexport function getLoadersFromContext(\n  loaders: Loader[] | Loader | undefined,\n  context?: LoaderContext\n) {\n  // A single non-array loader is force selected, but only on top-level (context === null)\n  if (!context && loaders && !Array.isArray(loaders)) {\n    return loaders;\n  }\n\n  // Create a merged list\n  let candidateLoaders;\n  if (loaders) {\n    candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];\n  }\n  if (context && context.loaders) {\n    const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];\n    candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;\n  }\n  // If no loaders, return null to look in globally registered loaders\n  return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;\n}\n"],"file":"loader-context.js"}

package/dist/lib/loader-utils/loggers.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/loader-utils/loggers.ts"],"names":["Log","probeLog","id","NullLog","log","info","warn","error","ConsoleLog","constructor","console","args","bind"],"mappings":";AACA,SAAQA,GAAR,QAAkB,UAAlB;AAEA,OAAO,MAAMC,QAAQ,GAAG,IAAID,GAAJ,CAAQ;AAACE,EAAAA,EAAE,EAAE;AAAL,CAAR,CAAjB;AAGP,OAAO,MAAMC,OAAN,CAAc;AACnBC,EAAAA,GAAG,GAAG;AACJ,WAAO,MAAM,CAAE,CAAf;AACD;;AACDC,EAAAA,IAAI,GAAG;AACL,WAAO,MAAM,CAAE,CAAf;AACD;;AACDC,EAAAA,IAAI,GAAG;AACL,WAAO,MAAM,CAAE,CAAf;AACD;;AACDC,EAAAA,KAAK,GAAG;AACN,WAAO,MAAM,CAAE,CAAf;AACD;;AAZkB;AAgBrB,OAAO,MAAMC,UAAN,CAAiB;AAGtBC,EAAAA,WAAW,GAAG;AAAA;;AACZ,SAAKC,OAAL,GAAeA,OAAf;AACD;;AACDN,EAAAA,GAAG,CAAC,GAAGO,IAAJ,EAAU;AACX,WAAO,KAAKD,OAAL,CAAaN,GAAb,CAAiBQ,IAAjB,CAAsB,KAAKF,OAA3B,EAAoC,GAAGC,IAAvC,CAAP;AACD;;AACDN,EAAAA,IAAI,CAAC,GAAGM,IAAJ,EAAU;AACZ,WAAO,KAAKD,OAAL,CAAaL,IAAb,CAAkBO,IAAlB,CAAuB,KAAKF,OAA5B,EAAqC,GAAGC,IAAxC,CAAP;AACD;;AACDL,EAAAA,IAAI,CAAC,GAAGK,IAAJ,EAAU;AACZ,WAAO,KAAKD,OAAL,CAAaJ,IAAb,CAAkBM,IAAlB,CAAuB,KAAKF,OAA5B,EAAqC,GAAGC,IAAxC,CAAP;AACD;;AACDJ,EAAAA,KAAK,CAAC,GAAGI,IAAJ,EAAU;AACb,WAAO,KAAKD,OAAL,CAAaH,KAAb,CAAmBK,IAAnB,CAAwB,KAAKF,OAA7B,EAAsC,GAAGC,IAAzC,CAAP;AACD;;AAjBqB","sourcesContent":["// probe.gl Log compatible loggers\nimport {Log} from 'probe.gl';\n\nexport const probeLog = new Log({id: 'loaders.gl'});\n\n// Logs nothing\nexport class NullLog {\n  log() {\n    return () => {};\n  }\n  info() {\n    return () => {};\n  }\n  warn() {\n    return () => {};\n  }\n  error() {\n    return () => {};\n  }\n}\n\n// Logs to console\nexport class ConsoleLog {\n  console;\n\n  constructor() {\n    this.console = console; // eslint-disable-line\n  }\n  log(...args) {\n    return this.console.log.bind(this.console, ...args);\n  }\n  info(...args) {\n    return this.console.info.bind(this.console, ...args);\n  }\n  warn(...args) {\n    return this.console.warn.bind(this.console, ...args);\n  }\n  error(...args) {\n    return this.console.error.bind(this.console, ...args);\n  }\n}\n"],"file":"loggers.js"}

package/dist/lib/loader-utils/normalize-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/loader-utils/normalize-loader.ts"],"names":["assert","isLoaderObject","loader","Array","isArray","hasExtensions","extensions","normalizeLoader","options","parseTextSync","parseText","text","binary"],"mappings":"AACA,SAAQA,MAAR,QAAqB,0BAArB;AAEA,OAAO,SAASC,cAAT,CAAwBC,MAAxB,EAA+C;AAAA;;AACpD,MAAI,CAACA,MAAL,EAAa;AACX,WAAO,KAAP;AACD;;AAED,MAAIC,KAAK,CAACC,OAAN,CAAcF,MAAd,CAAJ,EAA2B;AACzBA,IAAAA,MAAM,GAAGA,MAAM,CAAC,CAAD,CAAf;AACD;;AAED,QAAMG,aAAa,GAAGF,KAAK,CAACC,OAAN,YAAcF,MAAd,4CAAc,QAAQI,UAAtB,CAAtB;AAWA,SAAOD,aAAP;AACD;AAED,OAAO,SAASE,eAAT,CAAyBL,MAAzB,EAAiD;AAAA;;AAItDF,EAAAA,MAAM,CAACE,MAAD,EAAS,aAAT,CAAN;AACAF,EAAAA,MAAM,CAACC,cAAc,CAACC,MAAD,CAAf,EAAyB,gBAAzB,CAAN;AAKA,MAAIM,OAAJ;;AACA,MAAIL,KAAK,CAACC,OAAN,CAAcF,MAAd,CAAJ,EAA2B;AACzBM,IAAAA,OAAO,GAAGN,MAAM,CAAC,CAAD,CAAhB;AACAA,IAAAA,MAAM,GAAGA,MAAM,CAAC,CAAD,CAAf;AACAA,IAAAA,MAAM,GAAG,EACP,GAAGA,MADI;AAEPM,MAAAA,OAAO,EAAE,EAAC,GAAGN,MAAM,CAACM,OAAX;AAAoB,WAAGA;AAAvB;AAFF,KAAT;AAID;;AAMD,MAAI,YAAAN,MAAM,UAAN,oCAAQO,aAAR,gBAAyBP,MAAzB,qCAAyB,SAAQQ,SAArC,EAAgD;AAC9CR,IAAAA,MAAM,CAACS,IAAP,GAAc,IAAd;AACD;;AAED,MAAI,CAACT,MAAM,CAACS,IAAZ,EAAkB;AAChBT,IAAAA,MAAM,CAACU,MAAP,GAAgB,IAAhB;AACD;;AAED,SAAOV,MAAP;AACD","sourcesContent":["import type {Loader} from '@loaders.gl/loader-utils';\nimport {assert} from '@loaders.gl/loader-utils';\n\nexport function isLoaderObject(loader?: any): boolean {\n  if (!loader) {\n    return false;\n  }\n\n  if (Array.isArray(loader)) {\n    loader = loader[0];\n  }\n\n  const hasExtensions = Array.isArray(loader?.extensions);\n\n  /* Now handled by types and worker loaders do not have these\n  let hasParser =\n    loader.parseTextSync ||\n    loader.parseSync ||\n    loader.parse ||\n    loader.parseStream || // TODO Remove, Replace with parseInBatches\n    loader.parseInBatches;\n  */\n\n  return hasExtensions;\n}\n\nexport function normalizeLoader(loader: Loader): Loader {\n  // This error is fairly easy to trigger by mixing up import statements etc\n  // So we make an exception and add a developer error message for this case\n  // To help new users from getting stuck here\n  assert(loader, 'null loader');\n  assert(isLoaderObject(loader), 'invalid loader');\n\n  // NORMALIZE [LOADER, OPTIONS] => LOADER\n\n  // If [loader, options], create a new loaders object with options merged in\n  let options;\n  if (Array.isArray(loader)) {\n    options = loader[1];\n    loader = loader[0];\n    loader = {\n      ...loader,\n      options: {...loader.options, ...options}\n    };\n  }\n\n  // NORMALIZE text and binary flags\n  // Ensure at least one of text/binary flags are properly set\n\n  // @ts-expect-error\n  if (loader?.parseTextSync || loader?.parseText) {\n    loader.text = true;\n  }\n\n  if (!loader.text) {\n    loader.binary = true;\n  }\n\n  return loader;\n}\n"],"file":"normalize-loader.js"}

package/dist/lib/loader-utils/option-defaults.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/loader-utils/option-defaults.ts"],"names":["ConsoleLog","DEFAULT_LOADER_OPTIONS","fetch","mimeType","undefined","nothrow","log","CDN","worker","maxConcurrency","maxMobileConcurrency","reuseWorkers","_workerType","limit","_limitMB","batchSize","batchDebounceMs","metadata","transforms","REMOVED_LOADER_OPTIONS","throws","dataType","uri","method","headers","body","mode","credentials","cache","redirect","referrer","referrerPolicy","integrity","keepalive","signal"],"mappings":"AACA,SAAQA,UAAR,QAAyB,WAAzB;AAEA,OAAO,MAAMC,sBAAqC,GAAG;AAEnDC,EAAAA,KAAK,EAAE,IAF4C;AAGnDC,EAAAA,QAAQ,EAAEC,SAHyC;AAInDC,EAAAA,OAAO,EAAE,KAJ0C;AAKnDC,EAAAA,GAAG,EAAE,IAAIN,UAAJ,EAL8C;AAOnDO,EAAAA,GAAG,EAAE,+BAP8C;AAQnDC,EAAAA,MAAM,EAAE,IAR2C;AASnDC,EAAAA,cAAc,EAAE,CATmC;AAUnDC,EAAAA,oBAAoB,EAAE,CAV6B;AAWnDC,EAAAA,YAAY,EAAE,IAXqC;AAYnDC,EAAAA,WAAW,EAAE,EAZsC;AAcnDC,EAAAA,KAAK,EAAE,CAd4C;AAenDC,EAAAA,QAAQ,EAAE,CAfyC;AAgBnDC,EAAAA,SAAS,EAAE,MAhBwC;AAiBnDC,EAAAA,eAAe,EAAE,CAjBkC;AAkBnDC,EAAAA,QAAQ,EAAE,KAlByC;AAmBnDC,EAAAA,UAAU,EAAE;AAnBuC,CAA9C;AAsBP,OAAO,MAAMC,sBAAsB,GAAG;AACpCC,EAAAA,MAAM,EAAE,SAD4B;AAEpCC,EAAAA,QAAQ,EAAE,kBAF0B;AAGpCC,EAAAA,GAAG,EAAE,SAH+B;AAKpCC,EAAAA,MAAM,EAAE,cAL4B;AAMpCC,EAAAA,OAAO,EAAE,eAN2B;AAOpCC,EAAAA,IAAI,EAAE,YAP8B;AAQpCC,EAAAA,IAAI,EAAE,YAR8B;AASpCC,EAAAA,WAAW,EAAE,mBATuB;AAUpCC,EAAAA,KAAK,EAAE,aAV6B;AAWpCC,EAAAA,QAAQ,EAAE,gBAX0B;AAYpCC,EAAAA,QAAQ,EAAE,gBAZ0B;AAapCC,EAAAA,cAAc,EAAE,sBAboB;AAcpCC,EAAAA,SAAS,EAAE,iBAdyB;AAepCC,EAAAA,SAAS,EAAE,iBAfyB;AAgBpCC,EAAAA,MAAM,EAAE;AAhB4B,CAA/B","sourcesContent":["import type {LoaderOptions} from '@loaders.gl/loader-utils';\nimport {ConsoleLog} from './loggers';\n\nexport const DEFAULT_LOADER_OPTIONS: LoaderOptions = {\n  // baseUri\n  fetch: null,\n  mimeType: undefined,\n  nothrow: false,\n  log: new ConsoleLog(), // A probe.gl compatible (`log.log()()` syntax) that just logs to console\n\n  CDN: 'https://unpkg.com/@loaders.gl',\n  worker: true, // By default, use worker if provided by loader.\n  maxConcurrency: 3, // How many worker instances should be created for each loader.\n  maxMobileConcurrency: 1, // How many worker instances should be created for each loader on mobile devices.\n  reuseWorkers: true, // By default reuse workers,\n  _workerType: '', // 'test' to use locally generated workers\n\n  limit: 0,\n  _limitMB: 0,\n  batchSize: 'auto',\n  batchDebounceMs: 0,\n  metadata: false, // TODO - currently only implemented for parseInBatches, adds initial metadata batch,\n  transforms: []\n};\n\nexport const REMOVED_LOADER_OPTIONS = {\n  throws: 'nothrow',\n  dataType: '(no longer used)',\n  uri: 'baseUri',\n  // Warn if fetch options are used on top-level\n  method: 'fetch.method',\n  headers: 'fetch.headers',\n  body: 'fetch.body',\n  mode: 'fetch.mode',\n  credentials: 'fetch.credentials',\n  cache: 'fetch.cache',\n  redirect: 'fetch.redirect',\n  referrer: 'fetch.referrer',\n  referrerPolicy: 'fetch.referrerPolicy',\n  integrity: 'fetch.integrity',\n  keepalive: 'fetch.keepalive',\n  signal: 'fetch.signal'\n};\n"],"file":"option-defaults.js"}

package/dist/lib/loader-utils/option-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/loader-utils/option-utils.ts"],"names":["isPureObject","isObject","fetchFile","probeLog","NullLog","DEFAULT_LOADER_OPTIONS","REMOVED_LOADER_OPTIONS","getGlobalLoaderState","globalThis","loaders","_state","getGlobalLoaderOptions","state","globalOptions","setGlobalOptions","options","normalizeOptionsInternal","normalizeOptions","loader","url","Array","isArray","validateOptions","getFetchFunction","context","fetchOptions","fetch","validateOptionsObject","idOptions","id","loaderOptions","deprecatedOptions","defaultOptions","loaderName","prefix","key","isSubOptions","isBaseUriOption","isWorkerUrlOption","warn","suggestion","findSimilarOption","optionKey","lowerCaseOptionKey","toLowerCase","bestSuggestion","lowerCaseKey","isPartialMatch","startsWith","loaderDefaultOptions","mergedOptions","addUrlOptions","log","mergeNestedFields","value","baseUri"],"mappings":"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","sourcesContent":["import type {Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {isPureObject, isObject} from '../../javascript-utils/is-type';\nimport {fetchFile} from '../fetch/fetch-file';\nimport {probeLog, NullLog} from './loggers';\nimport {DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS} from './option-defaults';\n/**\n * Global state for loaders.gl. Stored on `global.loaders._state`\n */\ntype GlobalLoaderState = {\n  loaderRegistry: Loader[];\n  globalOptions: {[key: string]: any};\n};\n\n/**\n * Helper for safely accessing global loaders.gl variables\n * Wraps initialization of global variable in function to defeat overly aggressive tree-shakers\n */\nexport function getGlobalLoaderState(): GlobalLoaderState {\n  // @ts-ignore\n  globalThis.loaders = globalThis.loaders || {};\n  // @ts-ignore\n  const {loaders} = globalThis;\n\n  // Add _state object to keep separate from modules added to globalThis.loaders\n  loaders._state = loaders._state || {};\n  return loaders._state;\n}\n\n// Store global loader options on the global object to increase chances of cross loaders-version interoperability\n// NOTE: This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks\nconst getGlobalLoaderOptions = () => {\n  const state = getGlobalLoaderState();\n  // Ensure all default loader options from this library are mentioned\n  state.globalOptions = state.globalOptions || {...DEFAULT_LOADER_OPTIONS};\n  return state.globalOptions;\n};\n\n/**\n * Set global loader options\n * @param options\n */\nexport function setGlobalOptions(options: object): void {\n  const state = getGlobalLoaderState();\n  const globalOptions = getGlobalLoaderOptions();\n  state.globalOptions = normalizeOptionsInternal(globalOptions, options);\n}\n\n/**\n * Merges options with global opts and loader defaults, also injects baseUri\n * @param options\n * @param loader\n * @param loaders\n * @param url\n */\nexport function normalizeOptions(\n  options: object,\n  loader: Loader,\n  loaders?: Loader[],\n  url?: string\n): object {\n  loaders = loaders || [];\n  loaders = Array.isArray(loaders) ? loaders : [loaders];\n\n  validateOptions(options, loaders);\n  return normalizeOptionsInternal(loader, options, url);\n}\n\n/**\n * Gets the current fetch function from options and context\n * @param options\n * @param context\n */\nexport function getFetchFunction(\n  options?: LoaderOptions,\n  context?: Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>\n) {\n  const globalOptions = getGlobalLoaderOptions();\n\n  const fetchOptions = options || globalOptions;\n\n  // options.fetch can be a function\n  if (typeof fetchOptions.fetch === 'function') {\n    return fetchOptions.fetch;\n  }\n\n  // options.fetch can be an options object\n  if (isObject(fetchOptions.fetch)) {\n    return (url) => fetchFile(url, fetchOptions);\n  }\n\n  // else refer to context (from parent loader) if available\n  if (context?.fetch) {\n    return context?.fetch;\n  }\n\n  // else return the default fetch function\n  return fetchFile;\n}\n\n// VALIDATE OPTIONS\n\n/**\n * Warn for unsupported options\n * @param options\n * @param loaders\n */\nfunction validateOptions(options: LoaderOptions, loaders: Loader[]) {\n  // Check top level options\n  validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders);\n  for (const loader of loaders) {\n    // Get the scoped, loader specific options from the user supplied options\n    const idOptions = (options && options[loader.id]) || {};\n\n    // Get scoped, loader specific default and deprecated options from the selected loader\n    const loaderOptions = (loader.options && loader.options[loader.id]) || {};\n    const deprecatedOptions =\n      (loader.deprecatedOptions && loader.deprecatedOptions[loader.id]) || {};\n\n    // Validate loader specific options\n    validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);\n  }\n}\n\n// eslint-disable-next-line max-params, complexity\nfunction validateOptionsObject(\n  options,\n  id: string | null,\n  defaultOptions,\n  deprecatedOptions,\n  loaders: Loader[]\n) {\n  const loaderName = id || 'Top level';\n  const prefix = id ? `${id}.` : '';\n\n  for (const key in options) {\n    // If top level option value is an object it could options for a loader, so ignore\n    const isSubOptions = !id && isObject(options[key]);\n    const isBaseUriOption = key === 'baseUri' && !id;\n    const isWorkerUrlOption = key === 'workerUrl' && id;\n    // <loader>.workerUrl requires special handling as it is now auto-generated and no longer specified as a default option.\n    if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {\n      // Issue deprecation warnings\n      if (key in deprecatedOptions) {\n        probeLog.warn(\n          `${loaderName} loader option \\'${prefix}${key}\\' no longer supported, use \\'${deprecatedOptions[key]}\\'`\n        )();\n      } else if (!isSubOptions) {\n        const suggestion = findSimilarOption(key, loaders);\n        probeLog.warn(\n          `${loaderName} loader option \\'${prefix}${key}\\' not recognized. ${suggestion}`\n        )();\n      }\n    }\n  }\n}\n\nfunction findSimilarOption(optionKey, loaders) {\n  const lowerCaseOptionKey = optionKey.toLowerCase();\n  let bestSuggestion = '';\n  for (const loader of loaders) {\n    for (const key in loader.options) {\n      if (optionKey === key) {\n        return `Did you mean \\'${loader.id}.${key}\\'?`;\n      }\n      const lowerCaseKey = key.toLowerCase();\n      const isPartialMatch =\n        lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey);\n      if (isPartialMatch) {\n        bestSuggestion = bestSuggestion || `Did you mean \\'${loader.id}.${key}\\'?`;\n      }\n    }\n  }\n  return bestSuggestion;\n}\n\nfunction normalizeOptionsInternal(loader, options, url?: string) {\n  const loaderDefaultOptions = loader.options || {};\n\n  const mergedOptions = {...loaderDefaultOptions};\n\n  addUrlOptions(mergedOptions, url);\n\n  // LOGGING: options.log can be set to `null` to defeat logging\n  if (mergedOptions.log === null) {\n    mergedOptions.log = new NullLog();\n  }\n\n  mergeNestedFields(mergedOptions, getGlobalLoaderOptions());\n  mergeNestedFields(mergedOptions, options);\n\n  return mergedOptions;\n}\n\n// Merge nested options objects\nfunction mergeNestedFields(mergedOptions, options) {\n  for (const key in options) {\n    // Check for nested options\n    // object in options => either no key in defaultOptions or object in defaultOptions\n    if (key in options) {\n      const value = options[key];\n      if (isPureObject(value) && isPureObject(mergedOptions[key])) {\n        mergedOptions[key] = {\n          ...mergedOptions[key],\n          ...options[key]\n        };\n      } else {\n        mergedOptions[key] = options[key];\n      }\n    }\n    // else: No need to merge nested opts, and the initial merge already copied over the nested options\n  }\n}\n\n// Harvest information from the url\n// TODO - baseUri should be a directory, i.e. remove file component from baseUri\n// TODO - extract extension?\n// TODO - extract query parameters?\n// TODO - should these be injected on context instead of options?\nfunction addUrlOptions(options, url?: string) {\n  if (url && !('baseUri' in options)) {\n    options.baseUri = url;\n  }\n}\n"],"file":"option-utils.js"}

package/dist/lib/progress/fetch-progress.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/progress/fetch-progress.ts"],"names":["fetchProgress","response","onProgress","onDone","onError","ok","body","contentLength","headers","get","totalBytes","parseInt","ReadableStream","getReader","progressStream","start","controller","reader","read","Response","loadedBytes","done","value","close","byteLength","percent","Math","round","enqueue","error"],"mappings":"AAKA,eAAe,eAAeA,aAAf,CACbC,QADa,EAEbC,UAFa,EAGbC,MAAM,GAAG,MAAM,CAAE,CAHJ,EAIbC,OAAO,GAAG,MAAM,CAAE,CAJL,EAKb;AACAH,EAAAA,QAAQ,GAAG,MAAMA,QAAjB;;AACA,MAAI,CAACA,QAAQ,CAACI,EAAd,EAAkB;AAEhB,WAAOJ,QAAP;AACD;;AACD,QAAMK,IAAI,GAAGL,QAAQ,CAACK,IAAtB;;AACA,MAAI,CAACA,IAAL,EAAW;AAET,WAAOL,QAAP;AACD;;AACD,QAAMM,aAAa,GAAGN,QAAQ,CAACO,OAAT,CAAiBC,GAAjB,CAAqB,gBAArB,KAA0C,CAAhE;AACA,QAAMC,UAAU,GAAGH,aAAa,IAAII,QAAQ,CAACJ,aAAD,CAA5C;;AACA,MAAI,EAAEA,aAAa,GAAG,CAAlB,CAAJ,EAA0B;AACxB,WAAON,QAAP;AACD;;AAED,MAAI,OAAOW,cAAP,KAA0B,WAA1B,IAAyC,CAACN,IAAI,CAACO,SAAnD,EAA8D;AAC5D,WAAOZ,QAAP;AACD;;AAGD,QAAMa,cAAc,GAAG,IAAIF,cAAJ,CAAmB;AACxC,UAAMG,KAAN,CAAYC,UAAZ,EAAwB;AACtB,YAAMC,MAAM,GAAGX,IAAI,CAACO,SAAL,EAAf;AACA,YAAMK,IAAI,CAACF,UAAD,EAAaC,MAAb,EAAqB,CAArB,EAAwBP,UAAxB,EAAoCR,UAApC,EAAgDC,MAAhD,EAAwDC,OAAxD,CAAV;AACD;;AAJuC,GAAnB,CAAvB;AAOA,SAAO,IAAIe,QAAJ,CAAaL,cAAb,CAAP;AACD;;AAKD,eAAeI,IAAf,CAAoBF,UAApB,EAAgCC,MAAhC,EAAwCG,WAAxC,EAAqDV,UAArD,EAAiER,UAAjE,EAA6EC,MAA7E,EAAqFC,OAArF,EAA8F;AAC5F,MAAI;AACF,UAAM;AAACiB,MAAAA,IAAD;AAAOC,MAAAA;AAAP,QAAgB,MAAML,MAAM,CAACC,IAAP,EAA5B;;AACA,QAAIG,IAAJ,EAAU;AACRlB,MAAAA,MAAM;AACNa,MAAAA,UAAU,CAACO,KAAX;AACA;AACD;;AACDH,IAAAA,WAAW,IAAIE,KAAK,CAACE,UAArB;AACA,UAAMC,OAAO,GAAGC,IAAI,CAACC,KAAL,CAAYP,WAAW,GAAGV,UAAf,GAA6B,GAAxC,CAAhB;AACAR,IAAAA,UAAU,CAACuB,OAAD,EAAU;AAACL,MAAAA,WAAD;AAAcV,MAAAA;AAAd,KAAV,CAAV;AACAM,IAAAA,UAAU,CAACY,OAAX,CAAmBN,KAAnB;AACA,UAAMJ,IAAI,CAACF,UAAD,EAAaC,MAAb,EAAqBG,WAArB,EAAkCV,UAAlC,EAA8CR,UAA9C,EAA0DC,MAA1D,EAAkEC,OAAlE,CAAV;AACD,GAZD,CAYE,OAAOyB,KAAP,EAAc;AACdb,IAAAA,UAAU,CAACa,KAAX,CAAiBA,KAAjB;AACAzB,IAAAA,OAAO,CAACyB,KAAD,CAAP;AACD;AACF","sourcesContent":["// Forked from github AnthumChris/fetch-progress-indicators under MIT license\n\n/**\n * Intercepts the Response stream and creates a new Response\n */\nexport default async function fetchProgress(\n  response: Response | Promise<Response>,\n  onProgress: any, // TODO better callback types\n  onDone = () => {},\n  onError = () => {}\n) {\n  response = await response;\n  if (!response.ok) {\n    // ERROR checking needs to be done separately\n    return response;\n  }\n  const body = response.body;\n  if (!body) {\n    // 'ReadableStream not yet supported in this browser.\n    return response;\n  }\n  const contentLength = response.headers.get('content-length') || 0;\n  const totalBytes = contentLength && parseInt(contentLength);\n  if (!(contentLength > 0)) {\n    return response;\n  }\n  // Currently override only implemented in browser\n  if (typeof ReadableStream === 'undefined' || !body.getReader) {\n    return response;\n  }\n\n  // Create a new stream that invisbly wraps original stream\n  const progressStream = new ReadableStream({\n    async start(controller) {\n      const reader = body.getReader();\n      await read(controller, reader, 0, totalBytes, onProgress, onDone, onError);\n    }\n  });\n\n  return new Response(progressStream);\n}\n\n// Forward to original streams controller\n// TODO - this causes a crazy deep \"async stack\"... rewrite as async iterator?\n// eslint-disable-next-line max-params\nasync function read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError) {\n  try {\n    const {done, value} = await reader.read();\n    if (done) {\n      onDone();\n      controller.close();\n      return;\n    }\n    loadedBytes += value.byteLength;\n    const percent = Math.round((loadedBytes / totalBytes) * 100);\n    onProgress(percent, {loadedBytes, totalBytes});\n    controller.enqueue(value);\n    await read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);\n  } catch (error) {\n    controller.error(error);\n    onError(error);\n  }\n}\n"],"file":"fetch-progress.js"}