@loaders.gl/core 3.1.0-alpha.2 → 3.1.0-beta.1

package/dist/es5/null-loader.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NullLoader = exports.NullWorkerLoader = void 0;
+const VERSION = typeof "3.1.0-beta.1" !== 'undefined' ? "3.1.0-beta.1" : 'latest';
+const NullWorkerLoader = {
+  name: 'Null loader',
+  id: 'null',
+  module: 'core',
+  version: VERSION,
+  worker: true,
+  mimeTypes: ['application/x.empty'],
+  extensions: ['null'],
+  tests: [() => false],
+  options: {
+    null: {}
+  }
+};
+exports.NullWorkerLoader = NullWorkerLoader;
+const NullLoader = {
+  name: 'Null loader',
+  id: 'null',
+  module: 'core',
+  version: VERSION,
+  mimeTypes: ['application/x.empty'],
+  extensions: ['null'],
+  parse: async arrayBuffer => arrayBuffer,
+  parseSync: arrayBuffer => arrayBuffer,
+  parseInBatches: async function* generator(asyncIterator) {
+    for await (const batch of asyncIterator) {
+      yield batch;
+    }
+  },
+  tests: [() => false],
+  options: {
+    null: {}
+  }
+};
+exports.NullLoader = NullLoader;
+//# sourceMappingURL=null-loader.js.map

package/dist/{null-loader.js.map → es5/null-loader.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/null-loader.ts"],"names":["VERSION","NullWorkerLoader","name","id","module","version","worker","mimeTypes","extensions","tests","options","null","NullLoader","parse","arrayBuffer","parseSync","parseInBatches","generator","asyncIterator","batch"],"mappings":"AAEA,MAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAOA,OAAO,MAAMC,gBAAwB,GAAG;AACtCC,EAAAA,IAAI,EAAE,aADgC;AAEtCC,EAAAA,EAAE,EAAE,MAFkC;AAGtCC,EAAAA,MAAM,EAAE,MAH8B;AAItCC,EAAAA,OAAO,EAAEL,OAJ6B;AAKtCM,EAAAA,MAAM,EAAE,IAL8B;AAMtCC,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAN2B;AAOtCC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAP0B;AAQtCC,EAAAA,KAAK,EAAE,CAAC,MAAM,KAAP,CAR+B;AAStCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAT6B,CAAjC;AAiBP,OAAO,MAAMC,UAA4B,GAAG;AAC1CV,EAAAA,IAAI,EAAE,aADoC;AAE1CC,EAAAA,EAAE,EAAE,MAFsC;AAG1CC,EAAAA,MAAM,EAAE,MAHkC;AAI1CC,EAAAA,OAAO,EAAEL,OAJiC;AAK1CO,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAL+B;AAM1CC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAN8B;AAO1CK,EAAAA,KAAK,EAAE,MAAOC,WAAP,IAAuBA,WAPY;AAQ1CC,EAAAA,SAAS,EAAGD,WAAD,IAAiBA,WARc;AAS1CE,EAAAA,cAAc,EAAE,gBAAgBC,SAAhB,CAA0BC,aAA1B,EAAyC;AACvD,eAAW,MAAMC,KAAjB,IAA0BD,aAA1B,EAAyC;AACvC,YAAMC,KAAN;AACD;AACF,GAbyC;AAc1CV,EAAAA,KAAK,EAAE,CAAC,MAAM,KAAP,CAdmC;AAe1CC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAfiC,CAArC","sourcesContent":["// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nimport {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullWorkerLoader: Loader = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  worker: true,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullLoader: LoaderWithParser = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  parse: async (arrayBuffer) => arrayBuffer,\n  parseSync: (arrayBuffer) => arrayBuffer,\n  parseInBatches: async function* generator(asyncIterator) {\n    for await (const batch of asyncIterator) {\n      yield batch;\n    }\n  },\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n"],"file":"null-loader.js"}
+{"version":3,"sources":["../../src/null-loader.ts"],"names":["VERSION","NullWorkerLoader","name","id","module","version","worker","mimeTypes","extensions","tests","options","null","NullLoader","parse","arrayBuffer","parseSync","parseInBatches","generator","asyncIterator","batch"],"mappings":";;;;;;AAEA,MAAMA,OAAO,GAAG,0BAAuB,WAAvB,oBAAmD,QAAnE;AAOO,MAAMC,gBAAwB,GAAG;AACtCC,EAAAA,IAAI,EAAE,aADgC;AAEtCC,EAAAA,EAAE,EAAE,MAFkC;AAGtCC,EAAAA,MAAM,EAAE,MAH8B;AAItCC,EAAAA,OAAO,EAAEL,OAJ6B;AAKtCM,EAAAA,MAAM,EAAE,IAL8B;AAMtCC,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAN2B;AAOtCC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAP0B;AAQtCC,EAAAA,KAAK,EAAE,CAAC,MAAM,KAAP,CAR+B;AAStCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAT6B,CAAjC;;AAiBA,MAAMC,UAA4B,GAAG;AAC1CV,EAAAA,IAAI,EAAE,aADoC;AAE1CC,EAAAA,EAAE,EAAE,MAFsC;AAG1CC,EAAAA,MAAM,EAAE,MAHkC;AAI1CC,EAAAA,OAAO,EAAEL,OAJiC;AAK1CO,EAAAA,SAAS,EAAE,CAAC,qBAAD,CAL+B;AAM1CC,EAAAA,UAAU,EAAE,CAAC,MAAD,CAN8B;AAO1CK,EAAAA,KAAK,EAAE,MAAOC,WAAP,IAAuBA,WAPY;AAQ1CC,EAAAA,SAAS,EAAGD,WAAD,IAAiBA,WARc;AAS1CE,EAAAA,cAAc,EAAE,gBAAgBC,SAAhB,CAA0BC,aAA1B,EAAyC;AACvD,eAAW,MAAMC,KAAjB,IAA0BD,aAA1B,EAAyC;AACvC,YAAMC,KAAN;AACD;AACF,GAbyC;AAc1CV,EAAAA,KAAK,EAAE,CAAC,MAAM,KAAP,CAdmC;AAe1CC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAfiC,CAArC","sourcesContent":["// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nimport {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullWorkerLoader: Loader = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  worker: true,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n\n/**\n * Loads any data and returns null (or optionally passes through data unparsed)\n */\nexport const NullLoader: LoaderWithParser = {\n  name: 'Null loader',\n  id: 'null',\n  module: 'core',\n  version: VERSION,\n  mimeTypes: ['application/x.empty'],\n  extensions: ['null'],\n  parse: async (arrayBuffer) => arrayBuffer,\n  parseSync: (arrayBuffer) => arrayBuffer,\n  parseInBatches: async function* generator(asyncIterator) {\n    for await (const batch of asyncIterator) {\n      yield batch;\n    }\n  },\n  tests: [() => false],\n  options: {\n    null: {}\n  }\n};\n"],"file":"null-loader.js"}

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

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

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

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

package/dist/esm/bundle.js

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

package/dist/esm/bundle.js.map

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

package/dist/esm/core-addons/README.md

@@ -0,0 +1 @@
+These experimental classes should be moved to another module.

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

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=write-file-browser.js.map

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

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

package/dist/esm/index.js

@@ -0,0 +1,31 @@
+export { fetchFile } from './lib/fetch/fetch-file';
+export { readArrayBuffer } from './lib/fetch/read-array-buffer';
+export { readFileSync } from './lib/fetch/read-file';
+export { writeFile, writeFileSync } from './lib/fetch/write-file';
+export { setLoaderOptions } from './lib/api/set-loader-options';
+export { registerLoaders } from './lib/api/register-loaders';
+export { selectLoader, selectLoaderSync } from './lib/api/select-loader';
+export { parse } from './lib/api/parse';
+export { parseSync } from './lib/api/parse-sync';
+export { parseInBatches } from './lib/api/parse-in-batches';
+export { load } from './lib/api/load';
+export { loadInBatches } from './lib/api/load-in-batches';
+export { encode, encodeSync, encodeInBatches, encodeText, encodeURLtoURL } from './lib/api/encode';
+export { save, saveSync } from './lib/api/save';
+export { setPathPrefix, getPathPrefix, resolvePath } from '@loaders.gl/loader-utils';
+export { RequestScheduler } from '@loaders.gl/loader-utils';
+export { makeIterator } from './iterators/make-iterator/make-iterator';
+export { makeStream } from './iterators/make-stream/make-stream';
+export { makeDOMStream } from './iterators/make-stream/make-dom-stream';
+export { default as makeNodeStream } from './iterators/make-stream/make-node-stream';
+export { NullWorkerLoader, NullLoader } from './null-loader';
+export { JSONLoader } from '@loaders.gl/loader-utils';
+export { default as _fetchProgress } from './lib/progress/fetch-progress';
+export { default as _BrowserFileSystem } from './lib/filesystems/browser-filesystem';
+export { _unregisterLoaders } from './lib/api/register-loaders';
+export { isBrowser, isWorker, self, window, global, document } from '@loaders.gl/loader-utils';
+export { assert } from '@loaders.gl/loader-utils';
+export { forEach, concatenateArrayBuffersAsync } from '@loaders.gl/loader-utils';
+export { makeTextDecoderIterator, makeTextEncoderIterator, makeLineIterator, makeNumberedLineIterator } from '@loaders.gl/loader-utils';
+export { isPureObject, isPromise, isIterable, isAsyncIterable, isIterator, isResponse, isReadableStream, isWritableStream } from './javascript-utils/is-type';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"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","makeDOMStream","default","makeNodeStream","NullWorkerLoader","NullLoader","JSONLoader","_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,qCAAzB;AACA,SAAQC,aAAR,QAA4B,yCAA5B;AACA,SAAQC,OAAO,IAAIC,cAAnB,QAAwC,0CAAxC;AAGA,SAAQC,gBAAR,EAA0BC,UAA1B,QAA2C,eAA3C;AACA,SAAQC,UAAR,QAAyB,0BAAzB;AAGA,SAAQJ,OAAO,IAAIK,cAAnB,QAAwC,+BAAxC;AACA,SAAQL,OAAO,IAAIM,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-stream';\nexport {makeDOMStream} from './iterators/make-stream/make-dom-stream';\nexport {default as makeNodeStream} 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/esm/iterators/batch-iterators/timed-batch-iterator.js

@@ -0,0 +1,19 @@
+export async function* timedBatchIterator(batchIterator, timeout) {
+  let start = Date.now();
+  let batches = [];
+
+  for await (const batch of batchIterator) {
+    batches.push(batch);
+
+    if (Date.now() - start > timeout) {
+      yield batches;
+      start = Date.now();
+      batches = [];
+    }
+  }
+
+  if (batches) {
+    yield batches;
+  }
+}
+//# sourceMappingURL=timed-batch-iterator.js.map

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

@@ -0,0 +1 @@
+{"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/esm/iterators/make-iterator/make-array-buffer-iterator.js

@@ -0,0 +1,18 @@
+const DEFAULT_CHUNK_SIZE = 256 * 1024;
+export function* makeArrayBufferIterator(arrayBuffer, options = {}) {
+  const {
+    chunkSize = DEFAULT_CHUNK_SIZE
+  } = options;
+  let byteOffset = 0;
+
+  while (byteOffset < arrayBuffer.byteLength) {
+    const chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);
+    const chunk = new ArrayBuffer(chunkByteLength);
+    const sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);
+    const chunkArray = new Uint8Array(chunk);
+    chunkArray.set(sourceArray);
+    byteOffset += chunkByteLength;
+    yield chunk;
+  }
+}
+//# sourceMappingURL=make-array-buffer-iterator.js.map

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

@@ -0,0 +1 @@
+{"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/esm/iterators/make-iterator/make-blob-iterator.js

@@ -0,0 +1,13 @@
+const DEFAULT_CHUNK_SIZE = 1024 * 1024;
+export async function* makeBlobIterator(blob, options) {
+  const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
+  let offset = 0;
+
+  while (offset < blob.size) {
+    const end = offset + chunkSize;
+    const chunk = await blob.slice(offset, end).arrayBuffer();
+    offset = end;
+    yield chunk;
+  }
+}
+//# sourceMappingURL=make-blob-iterator.js.map

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

@@ -0,0 +1 @@
+{"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/esm/iterators/make-iterator/make-iterator.js

@@ -0,0 +1,30 @@
+import { makeStringIterator } from './make-string-iterator';
+import { makeArrayBufferIterator } from './make-array-buffer-iterator';
+import { makeBlobIterator } from './make-blob-iterator';
+import { makeStreamIterator } from './make-stream-iterator';
+import { isBlob, isReadableStream, isResponse } from '../../javascript-utils/is-type';
+export function makeIterator(data, options) {
+  if (typeof data === 'string') {
+    return makeStringIterator(data, options);
+  }
+
+  if (data instanceof ArrayBuffer) {
+    return makeArrayBufferIterator(data, options);
+  }
+
+  if (isBlob(data)) {
+    return makeBlobIterator(data, options);
+  }
+
+  if (isReadableStream(data)) {
+    return makeStreamIterator(data, options);
+  }
+
+  if (isResponse(data)) {
+    const response = data;
+    return makeStreamIterator(response.body, options);
+  }
+
+  throw new Error('makeIterator');
+}
+//# sourceMappingURL=make-iterator.js.map

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

@@ -0,0 +1 @@
+{"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/esm/iterators/make-iterator/make-stream-iterator.js

@@ -0,0 +1,39 @@
+import { isBrowser, toArrayBuffer } from '@loaders.gl/loader-utils';
+export function makeStreamIterator(stream, options) {
+  return isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
+}
+
+async function* makeBrowserStreamIterator(stream, options) {
+  const reader = stream.getReader();
+  let nextBatchPromise;
+
+  try {
+    while (true) {
+      const currentBatchPromise = nextBatchPromise || reader.read();
+
+      if (options !== null && options !== void 0 && options._streamReadAhead) {
+        nextBatchPromise = reader.read();
+      }
+
+      const {
+        done,
+        value
+      } = await currentBatchPromise;
+
+      if (done) {
+        return;
+      }
+
+      yield toArrayBuffer(value);
+    }
+  } catch (error) {
+    reader.releaseLock();
+  }
+}
+
+async function* makeNodeStreamIterator(stream, options) {
+  for await (const chunk of stream) {
+    yield toArrayBuffer(chunk);
+  }
+}
+//# sourceMappingURL=make-stream-iterator.js.map

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

@@ -0,0 +1 @@
+{"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/esm/iterators/make-iterator/make-string-iterator.js

@@ -0,0 +1,14 @@
+const DEFAULT_CHUNK_SIZE = 256 * 1024;
+export function* makeStringIterator(string, options) {
+  const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
+  let offset = 0;
+  const textEncoder = new TextEncoder();
+
+  while (offset < string.length) {
+    const chunkLength = Math.min(string.length - offset, chunkSize);
+    const chunk = string.slice(offset, offset + chunkLength);
+    offset += chunkLength;
+    yield textEncoder.encode(chunk);
+  }
+}
+//# sourceMappingURL=make-string-iterator.js.map

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

@@ -0,0 +1 @@
+{"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/esm/iterators/make-stream/make-dom-stream.js

@@ -0,0 +1,34 @@
+export function makeDOMStream(source, options) {
+  const iterator = source[Symbol.asyncIterator] ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
+  return new ReadableStream({
+    type: 'bytes',
+
+    async pull(controller) {
+      try {
+        const {
+          done,
+          value
+        } = await iterator.next();
+
+        if (done) {
+          controller.close();
+        } else {
+          controller.enqueue(new Uint8Array(value));
+        }
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+
+    async cancel() {
+      var _iterator$return;
+
+      await (iterator === null || iterator === void 0 ? void 0 : (_iterator$return = iterator.return) === null || _iterator$return === void 0 ? void 0 : _iterator$return.call(iterator));
+    }
+
+  }, {
+    highWaterMark: 2 ** 24,
+    ...options
+  });
+}
+//# sourceMappingURL=make-dom-stream.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/iterators/make-stream/make-dom-stream.ts"],"names":["makeDOMStream","source","options","iterator","Symbol","asyncIterator","ReadableStream","type","pull","controller","done","value","next","close","enqueue","Uint8Array","error","cancel","return","highWaterMark"],"mappings":"AAQA,OAAO,SAASA,aAAT,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 MakeDOMStreamOptions = {\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/** Builds a DOM stream from an iterator */\nexport function makeDOMStream<ArrayBuffer>(\n  source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>,\n  options?: MakeDOMStreamOptions\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/esm/iterators/make-stream/make-node-stream.js

@@ -0,0 +1,77 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { Readable } from 'stream';
+
+function makeNodeStream(source, options) {
+  const iterator = source[Symbol.asyncIterator] ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
+  return new AsyncIterableReadable(iterator, options);
+}
+
+class AsyncIterableReadable extends Readable {
+  constructor(it, options) {
+    super(options);
+
+    _defineProperty(this, "_pulling", void 0);
+
+    _defineProperty(this, "_bytesMode", void 0);
+
+    _defineProperty(this, "_iterator", void 0);
+
+    this._iterator = it;
+    this._pulling = false;
+    this._bytesMode = !options || !options.objectMode;
+  }
+
+  async _read(size) {
+    if (!this._pulling) {
+      this._pulling = true;
+      this._pulling = await this._pull(size, this._iterator);
+    }
+  }
+
+  async _destroy(error, cb) {
+    if (!this._iterator) {
+      return;
+    }
+
+    if (error) {
+      var _this$_iterator, _this$_iterator$throw;
+
+      await ((_this$_iterator = this._iterator) === null || _this$_iterator === void 0 ? void 0 : (_this$_iterator$throw = _this$_iterator.throw) === null || _this$_iterator$throw === void 0 ? void 0 : _this$_iterator$throw.call(_this$_iterator, error));
+    } else {
+      var _this$_iterator2, _this$_iterator2$retu;
+
+      await ((_this$_iterator2 = this._iterator) === null || _this$_iterator2 === void 0 ? void 0 : (_this$_iterator2$retu = _this$_iterator2.return) === null || _this$_iterator2$retu === void 0 ? void 0 : _this$_iterator2$retu.call(_this$_iterator2, error));
+    }
+
+    cb === null || cb === void 0 ? void 0 : cb(null);
+  }
+
+  async _pull(size, it) {
+    var _r;
+
+    const bm = this._bytesMode;
+    let r = null;
+
+    while (this.readable && !(r = await it.next()).done) {
+      if (size !== null) {
+        size -= bm && ArrayBuffer.isView(r.value) ? r.value.byteLength : 1;
+      }
+
+      if (!this.push(new Uint8Array(r.value)) || size <= 0) {
+        break;
+      }
+    }
+
+    if (((_r = r) !== null && _r !== void 0 && _r.done || !this.readable) && (this.push(null) || true)) {
+      var _it$return;
+
+      it === null || it === void 0 ? void 0 : (_it$return = it.return) === null || _it$return === void 0 ? void 0 : _it$return.call(it);
+    }
+
+    return !this.readable;
+  }
+
+}
+
+export default makeNodeStream;
+//# sourceMappingURL=make-node-stream.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/iterators/make-stream/make-node-stream.ts"],"names":["Readable","makeNodeStream","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,SAASC,cAAT,CACEC,MADF,EAEEC,OAFF,EAGY;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;;AAsD7C,eAAevB,cAAf","sourcesContent":["import {Readable, ReadableOptions} from 'stream';\n\nexport type MakeNodeStreamOptions = ReadableOptions;\n\n/** Builds a node stream from an iterator */\nfunction makeNodeStream<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\n// This module is marked `false` in the the \"browser\" field of the `package.json` for\n// `@loaders.gl/core`. We avoid using named exports so that bundlers have an easier\n// time resolving this \"empty\" module.\nexport default makeNodeStream;\n"],"file":"make-node-stream.js"}

package/dist/esm/iterators/make-stream/make-stream.js

@@ -0,0 +1,7 @@
+import { isBrowser } from '@loaders.gl/loader-utils';
+import { makeDOMStream } from './make-dom-stream';
+import makeNodeStream from './make-node-stream';
+export function makeStream(data, options) {
+  return isBrowser ? makeDOMStream(data, options) : makeNodeStream(data, options);
+}
+//# sourceMappingURL=make-stream.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/iterators/make-stream/make-stream.ts"],"names":["isBrowser","makeDOMStream","makeNodeStream","makeStream","data","options"],"mappings":"AAIA,SAAQA,SAAR,QAAwB,0BAAxB;AACA,SAAQC,aAAR,QAA4B,mBAA5B;AACA,OAAOC,cAAP,MAA2B,oBAA3B;AAOA,OAAO,SAASC,UAAT,CACLC,IADK,EAELC,OAFK,EAGe;AACpB,SAAOL,SAAS,GAAGC,aAAa,CAACG,IAAD,EAAOC,OAAP,CAAhB,GAAkCH,cAAc,CAACE,IAAD,EAAOC,OAAP,CAAhE;AACD","sourcesContent":["import type {ReadableStreamType} from '../../javascript-utils/is-type';\nimport type {MakeDOMStreamOptions} from './make-dom-stream';\nimport type {MakeNodeStreamOptions} from './make-node-stream';\n\nimport {isBrowser} from '@loaders.gl/loader-utils';\nimport {makeDOMStream} from './make-dom-stream';\nimport makeNodeStream from './make-node-stream';\n\nexport type MakeStreamOptions = MakeDOMStreamOptions | MakeNodeStreamOptions;\n\n/**\n * Returns a stream for an (async) iterator (works in both Node.js and browsers)\n */\nexport function makeStream(\n  data: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>,\n  options?: MakeStreamOptions\n): ReadableStreamType {\n  return isBrowser ? makeDOMStream(data, options) : makeNodeStream(data, options);\n}\n"],"file":"make-stream.js"}

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

@@ -0,0 +1,21 @@
+const isBoolean = x => typeof x === 'boolean';
+
+const isFunction = x => typeof x === 'function';
+
+export const isObject = x => x !== null && typeof x === 'object';
+export const isPureObject = x => isObject(x) && x.constructor === {}.constructor;
+export const isPromise = x => isObject(x) && isFunction(x.then);
+export const isIterable = x => x && typeof x[Symbol.iterator] === 'function';
+export const isAsyncIterable = x => x && typeof x[Symbol.asyncIterator] === 'function';
+export const isIterator = x => x && isFunction(x.next);
+export const isResponse = x => typeof Response !== 'undefined' && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
+export const isFile = x => typeof File !== 'undefined' && x instanceof File;
+export const isBlob = x => typeof Blob !== 'undefined' && x instanceof Blob;
+export const isBuffer = x => x && typeof x === 'object' && x.isBuffer;
+export const isWritableDOMStream = x => isObject(x) && isFunction(x.abort) && isFunction(x.getWriter);
+export const isReadableDOMStream = x => typeof ReadableStream !== 'undefined' && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
+export const isWritableNodeStream = x => isObject(x) && isFunction(x.end) && isFunction(x.write) && isBoolean(x.writable);
+export const isReadableNodeStream = x => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
+export const isReadableStream = x => isReadableDOMStream(x) || isReadableNodeStream(x);
+export const isWritableStream = x => isWritableDOMStream(x) || isWritableNodeStream(x);
+//# sourceMappingURL=is-type.js.map

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

@@ -0,0 +1 @@
+{"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":"AAKA,MAAMA,SAA8B,GAAIC,CAAD,IAAO,OAAOA,CAAP,KAAa,SAA3D;;AACA,MAAMC,UAA+B,GAAID,CAAD,IAAO,OAAOA,CAAP,KAAa,UAA5D;;AAEA,OAAO,MAAME,QAA6B,GAAIF,CAAD,IAAOA,CAAC,KAAK,IAAN,IAAc,OAAOA,CAAP,KAAa,QAAxE;AACP,OAAO,MAAMG,YAAiC,GAAIH,CAAD,IAC/CE,QAAQ,CAACF,CAAD,CAAR,IAAeA,CAAC,CAACI,WAAF,KAAkB,GAAGA,WAD/B;AAEP,OAAO,MAAMC,SAA8B,GAAIL,CAAD,IAAOE,QAAQ,CAACF,CAAD,CAAR,IAAeC,UAAU,CAACD,CAAC,CAACM,IAAH,CAAvE;AAEP,OAAO,MAAMC,UAA+B,GAAIP,CAAD,IAAOA,CAAC,IAAI,OAAOA,CAAC,CAACQ,MAAM,CAACC,QAAR,CAAR,KAA8B,UAAlF;AACP,OAAO,MAAMC,eAAoC,GAAIV,CAAD,IAClDA,CAAC,IAAI,OAAOA,CAAC,CAACQ,MAAM,CAACG,aAAR,CAAR,KAAmC,UADnC;AAEP,OAAO,MAAMC,UAA+B,GAAIZ,CAAD,IAAOA,CAAC,IAAIC,UAAU,CAACD,CAAC,CAACa,IAAH,CAA9D;AAEP,OAAO,MAAMC,UAA+B,GAAId,CAAD,IAC5C,OAAOe,QAAP,KAAoB,WAApB,IAAmCf,CAAC,YAAYe,QAAjD,IACCf,CAAC,IAAIA,CAAC,CAACgB,WAAP,IAAsBhB,CAAC,CAACiB,IAAxB,IAAgCjB,CAAC,CAACkB,IAF9B;AAIP,OAAO,MAAMC,MAA2B,GAAInB,CAAD,IAAO,OAAOoB,IAAP,KAAgB,WAAhB,IAA+BpB,CAAC,YAAYoB,IAAvF;AACP,OAAO,MAAMC,MAA2B,GAAIrB,CAAD,IAAO,OAAOsB,IAAP,KAAgB,WAAhB,IAA+BtB,CAAC,YAAYsB,IAAvF;AAGP,OAAO,MAAMC,QAA6B,GAAIvB,CAAD,IAAOA,CAAC,IAAI,OAAOA,CAAP,KAAa,QAAlB,IAA8BA,CAAC,CAACuB,QAA7E;AAEP,OAAO,MAAMC,mBAAwC,GAAIxB,CAAD,IACtDE,QAAQ,CAACF,CAAD,CAAR,IAAeC,UAAU,CAACD,CAAC,CAACyB,KAAH,CAAzB,IAAsCxB,UAAU,CAACD,CAAC,CAAC0B,SAAH,CAD3C;AAGP,OAAO,MAAMC,mBAAwC,GAAI3B,CAAD,IACrD,OAAO4B,cAAP,KAA0B,WAA1B,IAAyC5B,CAAC,YAAY4B,cAAvD,IACC1B,QAAQ,CAACF,CAAD,CAAR,IAAeC,UAAU,CAACD,CAAC,CAAC6B,GAAH,CAAzB,IAAoC5B,UAAU,CAACD,CAAC,CAAC8B,MAAH,CAA9C,IAA4D7B,UAAU,CAACD,CAAC,CAAC+B,SAAH,CAFlE;AAKP,OAAO,MAAMC,oBAAyC,GAAIhC,CAAD,IACvDE,QAAQ,CAACF,CAAD,CAAR,IAAeC,UAAU,CAACD,CAAC,CAACiC,GAAH,CAAzB,IAAoChC,UAAU,CAACD,CAAC,CAACkC,KAAH,CAA9C,IAA2DnC,SAAS,CAACC,CAAC,CAACmC,QAAH,CAD/D;AAEP,OAAO,MAAMC,oBAAyC,GAAIpC,CAAD,IACvDE,QAAQ,CAACF,CAAD,CAAR,IAAeC,UAAU,CAACD,CAAC,CAACqC,IAAH,CAAzB,IAAqCpC,UAAU,CAACD,CAAC,CAACsC,IAAH,CAA/C,IAA2DvC,SAAS,CAACC,CAAC,CAACuC,QAAH,CAD/D;AAEP,OAAO,MAAMC,gBAAqC,GAAIxC,CAAD,IACnD2B,mBAAmB,CAAC3B,CAAD,CAAnB,IAA0BoC,oBAAoB,CAACpC,CAAD,CADzC;AAEP,OAAO,MAAMyC,gBAAqC,GAAIzC,CAAD,IACnDwB,mBAAmB,CAACxB,CAAD,CAAnB,IAA0BgC,oBAAoB,CAAChC,CAAD,CADzC","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/esm/lib/api/encode.js

@@ -0,0 +1,91 @@
+import { concatenateArrayBuffers, resolvePath } from '@loaders.gl/loader-utils';
+import { isBrowser } from '@loaders.gl/loader-utils';
+import { writeFile } from '../fetch/write-file';
+import { fetchFile } from '../fetch/fetch-file';
+export async function encode(data, writer, options) {
+  if (writer.encode) {
+    return await writer.encode(data, options);
+  }
+
+  if (writer.encodeSync) {
+    return writer.encodeSync(data, options);
+  }
+
+  if (writer.encodeText) {
+    return new TextEncoder().encode(await writer.encodeText(data, options));
+  }
+
+  if (writer.encodeInBatches) {
+    const batches = encodeInBatches(data, writer, options);
+    const chunks = [];
+
+    for await (const batch of batches) {
+      chunks.push(batch);
+    }
+
+    return concatenateArrayBuffers(...chunks);
+  }
+
+  if (!isBrowser && writer.encodeURLtoURL) {
+    const tmpInputFilename = getTemporaryFilename('input');
+    await writeFile(tmpInputFilename, data);
+    const tmpOutputFilename = getTemporaryFilename('output');
+    const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
+    const response = await fetchFile(outputFilename);
+    return response.arrayBuffer();
+  }
+
+  throw new Error('Writer could not encode data');
+}
+export function encodeSync(data, writer, options) {
+  if (writer.encodeSync) {
+    return writer.encodeSync(data, options);
+  }
+
+  throw new Error('Writer could not synchronously encode data');
+}
+export async function encodeText(data, writer, options) {
+  if (writer.text && writer.encodeText) {
+    return await writer.encodeText(data, options);
+  }
+
+  if (writer.text && (writer.encode || writer.encodeInBatches)) {
+    const arrayBuffer = await encode(data, writer, options);
+    return new TextDecoder().decode(arrayBuffer);
+  }
+
+  throw new Error('Writer could not encode data as text');
+}
+export function encodeInBatches(data, writer, options) {
+  if (writer.encodeInBatches) {
+    const dataIterator = getIterator(data);
+    return writer.encodeInBatches(dataIterator, options);
+  }
+
+  throw new Error('Writer could not encode data in batches');
+}
+export async function encodeURLtoURL(inputUrl, outputUrl, writer, options) {
+  inputUrl = resolvePath(inputUrl);
+  outputUrl = resolvePath(outputUrl);
+
+  if (isBrowser || !writer.encodeURLtoURL) {
+    throw new Error();
+  }
+
+  const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);
+  return outputFilename;
+}
+
+function getIterator(data) {
+  const dataIterator = [{
+    table: data,
+    start: 0,
+    end: data.length
+  }];
+  return dataIterator;
+}
+
+function getTemporaryFilename(filename) {
+  return "/tmp/".concat(filename);
+}
+//# sourceMappingURL=encode.js.map