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

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

@@ -1,39 +1,96 @@
-import { isBrowser, toArrayBuffer } from '@loaders.gl/loader-utils';
-export function makeStreamIterator(stream, options) {
-  return isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStreamIterator = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+/**
+ * Returns an async iterable that reads from a stream (works in both Node.js and browsers)
+ * @param stream stream to iterator over
+ */
+function makeStreamIterator(stream, options) {
+    return loader_utils_1.isBrowser
+        ? makeBrowserStreamIterator(stream, options)
+        : makeNodeStreamIterator(stream, options);
 }
-
+exports.makeStreamIterator = makeStreamIterator;
+/**
+ * Returns an async iterable that reads from a DOM (browser) stream
+ * @param stream stream to iterate from
+ * @see https://jakearchibald.com/2017/async-iterators-and-generators/#making-streams-iterate
+ */
 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);
+    // WhatWG: stream is supposed to have a `getIterator` method
+    // if (typeof stream.getIterator === 'function') {
+    //   return stream.getIterator();
+    // }
+    // if (typeof stream[Symbol.asyncIterator] === 'function') {
+    //   return makeToArrayBufferIterator(stream);
+    // }
+    // In the browser, we first need to get a lock on the stream
+    const reader = stream.getReader();
+    let nextBatchPromise;
+    try {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const currentBatchPromise = nextBatchPromise || reader.read();
+            // Issue a read for an additional batch, while we await the next batch
+            // Idea is to make fetching happen in parallel with processing / parsing
+            if (options?._streamReadAhead) {
+                nextBatchPromise = reader.read();
+            }
+            // Read from the stream
+            // value is a Uint8Array
+            const { done, value } = await currentBatchPromise;
+            // Exit if we're done
+            if (done) {
+                return;
+            }
+            // Else yield the chunk
+            yield (0, loader_utils_1.toArrayBuffer)(value);
+        }
+    }
+    catch (error) {
+        // TODO - examples makes it look like this should always be called,
+        // but that generates exceptions so only call it if we do not reach the end
+        reader.releaseLock();
     }
-  } catch (error) {
-    reader.releaseLock();
-  }
 }
-
+/**
+ * Returns an async iterable that reads from a DOM (browser) stream
+ * @param stream stream to iterate from
+ * @note Requires Node.js >= 10
+ */
 async function* makeNodeStreamIterator(stream, options) {
-  for await (const chunk of stream) {
-    yield toArrayBuffer(chunk);
+    // Hacky test for node version to ensure we don't call bad polyfills
+    // NODE 10+: stream is an asyncIterator
+    for await (const chunk of stream) {
+        yield (0, loader_utils_1.toArrayBuffer)(chunk); // Coerce each chunk to ArrayBuffer
+    }
+}
+/* TODO - remove NODE < 10
+ * @see https://github.com/bustle/streaming-iterables, MIT license
+ *
+  if (typeof stream[Symbol.asyncIterator] === 'function') {
+    return;
+  }
+
+  // TODO - check if is this ever used in Node 10+?
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const data = stream.read();
+    if (data !== null) {
+      yield toArrayBuffer(data);
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    if (stream._readableState?.ended) {
+      return;
+    }
+    await onceReadable(stream);
   }
+
+async function onceReadable(stream: Readable): Promise<any> {
+  return new Promise((resolve) => {
+    stream.once('readable', resolve);
+  });
 }
-//# sourceMappingURL=make-stream-iterator.js.map
+  */

package/dist/iterators/make-iterator/make-string-iterator.d.ts

@@ -0,0 +1,9 @@
+import type { IteratorOptions } from './make-iterator';
+/**
+ * Returns an iterator that breaks a big string into chunks and yields them one-by-one as ArrayBuffers
+ * @param blob string to iterate over
+ * @param options
+ * @param options.chunkSize
+ */
+export declare function makeStringIterator(string: string, options?: IteratorOptions): Iterable<ArrayBuffer>;
+//# sourceMappingURL=make-string-iterator.d.ts.map

package/dist/iterators/make-iterator/make-string-iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-string-iterator.d.ts","sourceRoot":"","sources":["../../../src/iterators/make-iterator/make-string-iterator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAC;AAIrD;;;;;GAKG;AACH,wBAAiB,kBAAkB,CACjC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,eAAe,GACxB,QAAQ,CAAC,WAAW,CAAC,CAcvB"}

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

@@ -1,14 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStringIterator = void 0;
 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);
-  }
+/**
+ * Returns an iterator that breaks a big string into chunks and yields them one-by-one as ArrayBuffers
+ * @param blob string to iterate over
+ * @param options
+ * @param options.chunkSize
+ */
+function* makeStringIterator(string, options) {
+    const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;
+    let offset = 0;
+    const textEncoder = new TextEncoder();
+    while (offset < string.length) {
+        // Create a chunk of the right size
+        const chunkLength = Math.min(string.length - offset, chunkSize);
+        const chunk = string.slice(offset, offset + chunkLength);
+        offset += chunkLength;
+        // yield an ArrayBuffer chunk
+        yield textEncoder.encode(chunk);
+    }
 }
-//# sourceMappingURL=make-string-iterator.js.map
+exports.makeStringIterator = makeStringIterator;

package/dist/iterators/make-stream/make-dom-stream.d.ts

@@ -0,0 +1,9 @@
+export declare type MakeDOMStreamOptions = {
+    /** Stream allocates an arrayBuffer. Enables use of a default reader. */
+    autoAllocateChunkSize?: number;
+    /** Total number of chunks in queue before back pressure is applied */
+    highWaterMark?: number;
+};
+/** Builds a DOM stream from an iterator */
+export declare function makeDOMStream<ArrayBuffer>(source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>, options?: MakeDOMStreamOptions): ReadableStream;
+//# sourceMappingURL=make-dom-stream.d.ts.map

package/dist/iterators/make-stream/make-dom-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-dom-stream.d.ts","sourceRoot":"","sources":["../../../src/iterators/make-stream/make-dom-stream.ts"],"names":[],"mappings":"AAAA,oBAAY,oBAAoB,GAAG;IACjC,wEAAwE;IACxE,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,2CAA2C;AAC3C,wBAAgB,aAAa,CAAC,WAAW,EACvC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,aAAa,CAAC,WAAW,CAAC,EAC1D,OAAO,CAAC,EAAE,oBAAoB,GAC7B,cAAc,CAsChB"}

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

@@ -1,34 +1,41 @@
-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));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDOMStream = void 0;
+/** Builds a DOM stream from an iterator */
+function makeDOMStream(source, options) {
+    const iterator = source[Symbol.asyncIterator]
+        ? source[Symbol.asyncIterator]()
+        : source[Symbol.iterator]();
+    return new ReadableStream({
+        // Create a byte stream (enables `Response(stream).arrayBuffer()`)
+        // Only supported on Chrome
+        // See: https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController
+        // @ts-expect-error Only Chrome supports byte streams
+        type: 'bytes',
+        async pull(controller) {
+            try {
+                const { done, value } = await iterator.next();
+                if (done) {
+                    controller.close();
+                }
+                else {
+                    // TODO - ignores controller.desiredSize
+                    controller.enqueue(new Uint8Array(value));
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        async cancel() {
+            await iterator?.return?.();
         }
-      } 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
-  });
+    }, 
+    // options: QueingStrategy<Uint8Array>
+    {
+        // This is bytes, not chunks
+        highWaterMark: 2 ** 24,
+        ...options
+    });
 }
-//# sourceMappingURL=make-dom-stream.js.map
+exports.makeDOMStream = makeDOMStream;

package/dist/iterators/make-stream/make-node-stream.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { Readable, ReadableOptions } from 'stream';
+export declare type MakeNodeStreamOptions = ReadableOptions;
+/** Builds a node stream from an iterator */
+declare function makeNodeStream<ArrayBuffer>(source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>, options?: ReadableOptions): Readable;
+export default makeNodeStream;
+//# sourceMappingURL=make-node-stream.d.ts.map

package/dist/iterators/make-stream/make-node-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-node-stream.d.ts","sourceRoot":"","sources":["../../../src/iterators/make-stream/make-node-stream.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,QAAQ,EAAE,eAAe,EAAC,MAAM,QAAQ,CAAC;AAEjD,oBAAY,qBAAqB,GAAG,eAAe,CAAC;AAEpD,4CAA4C;AAC5C,iBAAS,cAAc,CAAC,WAAW,EACjC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,aAAa,CAAC,WAAW,CAAC,EAC1D,OAAO,CAAC,EAAE,eAAe,GACxB,QAAQ,CAKV;AAwDD,eAAe,cAAc,CAAC"}

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

@@ -1,77 +1,58 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { Readable } from 'stream';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+/** Builds a node stream from an iterator */
 function makeNodeStream(source, options) {
-  const iterator = source[Symbol.asyncIterator] ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
-  return new AsyncIterableReadable(iterator, 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);
+class AsyncIterableReadable extends stream_1.Readable {
+    constructor(it, options) {
+        super(options);
+        this._iterator = it;
+        this._pulling = false;
+        this._bytesMode = !options || !options.objectMode;
     }
-  }
-
-  async _destroy(error, cb) {
-    if (!this._iterator) {
-      return;
+    async _read(size) {
+        if (!this._pulling) {
+            this._pulling = true;
+            this._pulling = await this._pull(size, this._iterator);
+        }
     }
-
-    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));
+    async _destroy(error, cb) {
+        if (!this._iterator) {
+            return;
+        }
+        if (error) {
+            await this._iterator?.throw?.(error);
+        }
+        else {
+            await this._iterator?.return?.(error);
+        }
+        cb?.(null);
     }
-
-    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;
-      }
+    // eslint-disable-next-line complexity
+    async _pull(size, it) {
+        const bm = this._bytesMode;
+        let r = null;
+        // while (this.readable && !(r = await it.next(bm ? size : null)).done) {
+        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?.done || !this.readable) && (this.push(null) || true)) {
+            it?.return?.();
+        }
+        return !this.readable;
     }
-
-    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
+// This module is marked `false` in the the "browser" field of the `package.json` for
+// `@loaders.gl/core`. We avoid using named exports so that bundlers have an easier
+// time resolving this "empty" module.
+exports.default = makeNodeStream;

package/dist/iterators/make-stream/make-stream.d.ts

@@ -0,0 +1,9 @@
+import type { ReadableStreamType } from '../../javascript-utils/is-type';
+import type { MakeDOMStreamOptions } from './make-dom-stream';
+import type { MakeNodeStreamOptions } from './make-node-stream';
+export declare type MakeStreamOptions = MakeDOMStreamOptions | MakeNodeStreamOptions;
+/**
+ * Returns a stream for an (async) iterator (works in both Node.js and browsers)
+ */
+export declare function makeStream(data: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>, options?: MakeStreamOptions): ReadableStreamType;
+//# sourceMappingURL=make-stream.d.ts.map

package/dist/iterators/make-stream/make-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-stream.d.ts","sourceRoot":"","sources":["../../../src/iterators/make-stream/make-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AACvE,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,oBAAoB,CAAC;AAM9D,oBAAY,iBAAiB,GAAG,oBAAoB,GAAG,qBAAqB,CAAC;AAE7E;;GAEG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,aAAa,CAAC,WAAW,CAAC,EACxD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,kBAAkB,CAEpB"}

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

@@ -1,7 +1,16 @@
-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);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStream = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const make_dom_stream_1 = require("./make-dom-stream");
+const make_node_stream_1 = __importDefault(require("./make-node-stream"));
+/**
+ * Returns a stream for an (async) iterator (works in both Node.js and browsers)
+ */
+function makeStream(data, options) {
+    return loader_utils_1.isBrowser ? (0, make_dom_stream_1.makeDOMStream)(data, options) : (0, make_node_stream_1.default)(data, options);
 }
-//# sourceMappingURL=make-stream.js.map
+exports.makeStream = makeStream;

package/dist/javascript-utils/is-type.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import type { Readable } from 'stream';
+/** A DOM or Node readable stream */
+export declare type ReadableStreamType = ReadableStream | Readable;
+export declare const isObject: (x: any) => boolean;
+export declare const isPureObject: (x: any) => boolean;
+export declare const isPromise: (x: any) => boolean;
+export declare const isIterable: (x: any) => boolean;
+export declare const isAsyncIterable: (x: any) => boolean;
+export declare const isIterator: (x: any) => boolean;
+export declare const isResponse: (x: any) => boolean;
+export declare const isFile: (x: any) => boolean;
+export declare const isBlob: (x: any) => boolean;
+/** Check for Node.js `Buffer` without triggering bundler to include buffer polyfill */
+export declare const isBuffer: (x: any) => boolean;
+export declare const isWritableDOMStream: (x: any) => boolean;
+export declare const isReadableDOMStream: (x: any) => boolean;
+export declare const isWritableNodeStream: (x: any) => boolean;
+export declare const isReadableNodeStream: (x: any) => boolean;
+export declare const isReadableStream: (x: any) => boolean;
+export declare const isWritableStream: (x: any) => boolean;
+//# sourceMappingURL=is-type.d.ts.map

package/dist/javascript-utils/is-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-type.d.ts","sourceRoot":"","sources":["../../src/javascript-utils/is-type.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,QAAQ,CAAC;AAErC,oCAAoC;AACpC,oBAAY,kBAAkB,GAAG,cAAc,GAAG,QAAQ,CAAC;AAK3D,eAAO,MAAM,QAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAoD,CAAC;AACxF,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACU,CAAC;AAClD,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAkD,CAAC;AAEvF,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAA8D,CAAC;AACpG,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACU,CAAC;AACrD,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAwC,CAAC;AAE9E,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAEK,CAAC;AAE3C,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAiE,CAAC;AACnG,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAiE,CAAC;AAEnG,uFAAuF;AACvF,eAAO,MAAM,QAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAyD,CAAC;AAE7F,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACiB,CAAC;AAEhE,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAEyC,CAAC;AAGxF,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACmC,CAAC;AACnF,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACmC,CAAC;AACnF,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACQ,CAAC;AACpD,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACQ,CAAC"}

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

@@ -1,21 +1,41 @@
-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
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWritableStream = exports.isReadableStream = exports.isReadableNodeStream = exports.isWritableNodeStream = exports.isReadableDOMStream = exports.isWritableDOMStream = exports.isBuffer = exports.isBlob = exports.isFile = exports.isResponse = exports.isIterator = exports.isAsyncIterable = exports.isIterable = exports.isPromise = exports.isPureObject = exports.isObject = void 0;
+const isBoolean = (x) => typeof x === 'boolean';
+const isFunction = (x) => typeof x === 'function';
+const isObject = (x) => x !== null && typeof x === 'object';
+exports.isObject = isObject;
+const isPureObject = (x) => (0, exports.isObject)(x) && x.constructor === {}.constructor;
+exports.isPureObject = isPureObject;
+const isPromise = (x) => (0, exports.isObject)(x) && isFunction(x.then);
+exports.isPromise = isPromise;
+const isIterable = (x) => x && typeof x[Symbol.iterator] === 'function';
+exports.isIterable = isIterable;
+const isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === 'function';
+exports.isAsyncIterable = isAsyncIterable;
+const isIterator = (x) => x && isFunction(x.next);
+exports.isIterator = isIterator;
+const isResponse = (x) => (typeof Response !== 'undefined' && x instanceof Response) ||
+    (x && x.arrayBuffer && x.text && x.json);
+exports.isResponse = isResponse;
+const isFile = (x) => typeof File !== 'undefined' && x instanceof File;
+exports.isFile = isFile;
+const isBlob = (x) => typeof Blob !== 'undefined' && x instanceof Blob;
+exports.isBlob = isBlob;
+/** Check for Node.js `Buffer` without triggering bundler to include buffer polyfill */
+const isBuffer = (x) => x && typeof x === 'object' && x.isBuffer;
+exports.isBuffer = isBuffer;
+const isWritableDOMStream = (x) => (0, exports.isObject)(x) && isFunction(x.abort) && isFunction(x.getWriter);
+exports.isWritableDOMStream = isWritableDOMStream;
+const isReadableDOMStream = (x) => (typeof ReadableStream !== 'undefined' && x instanceof ReadableStream) ||
+    ((0, exports.isObject)(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader));
+exports.isReadableDOMStream = isReadableDOMStream;
+// Not implemented in Firefox: && isFunction(x.pipeTo)
+const isWritableNodeStream = (x) => (0, exports.isObject)(x) && isFunction(x.end) && isFunction(x.write) && isBoolean(x.writable);
+exports.isWritableNodeStream = isWritableNodeStream;
+const isReadableNodeStream = (x) => (0, exports.isObject)(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
+exports.isReadableNodeStream = isReadableNodeStream;
+const isReadableStream = (x) => (0, exports.isReadableDOMStream)(x) || (0, exports.isReadableNodeStream)(x);
+exports.isReadableStream = isReadableStream;
+const isWritableStream = (x) => (0, exports.isWritableDOMStream)(x) || (0, exports.isWritableNodeStream)(x);
+exports.isWritableStream = isWritableStream;

package/dist/lib/api/encode.d.ts

@@ -0,0 +1,26 @@
+import type { Writer, LoaderOptions } from '@loaders.gl/loader-utils';
+/**
+ * Encode loaded data into a binary ArrayBuffer using the specified Writer.
+ */
+export declare function encode(data: any, writer: Writer, options?: LoaderOptions): Promise<ArrayBuffer>;
+/**
+ * Encode loaded data into a binary ArrayBuffer using the specified Writer.
+ */
+export declare function encodeSync(data: any, writer: Writer, options?: LoaderOptions): ArrayBuffer;
+/**
+ * Encode loaded data to text using the specified Writer
+ * @note This is a convenience function not intended for production use on large input data.
+ * It is not optimized for performance. Data maybe converted from text to binary and back.
+ * @throws if the writer does not generate text output
+ */
+export declare function encodeText(data: any, writer: Writer, options?: LoaderOptions): Promise<string>;
+/**
+ * Encode loaded data into a sequence (iterator) of binary ArrayBuffers using the specified Writer.
+ */
+export declare function encodeInBatches(data: any, writer: Writer, options?: LoaderOptions): AsyncIterable<ArrayBuffer>;
+/**
+ * Encode data stored in a file (on disk) to another file.
+ * @note Node.js only. This function enables using command-line converters as "writers".
+ */
+export declare function encodeURLtoURL(inputUrl: any, outputUrl: any, writer: Writer, options: any): Promise<string>;
+//# sourceMappingURL=encode.d.ts.map

package/dist/lib/api/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../../src/lib/api/encode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAMpE;;GAEG;AACH,wBAAsB,MAAM,CAC1B,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,WAAW,CAAC,CA+CtB;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,WAAW,CAK1F;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,MAAM,CAAC,CAWjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,aAAa,GACtB,aAAa,CAAC,WAAW,CAAC,CAO5B;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAClC,QAAQ,KAAA,EACR,SAAS,KAAA,EACT,MAAM,EAAE,MAAM,EACd,OAAO,KAAA,GACN,OAAO,CAAC,MAAM,CAAC,CAQjB"}