@loaders.gl/core 4.2.0-alpha.4 → 4.2.0-alpha.6

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

@@ -1,25 +1,36 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { makeStringIterator } from "./make-string-iterator.js";
 import { makeArrayBufferIterator } from "./make-array-buffer-iterator.js";
 import { makeBlobIterator } from "./make-blob-iterator.js";
 import { makeStreamIterator } from "./make-stream-iterator.js";
 import { isBlob, isReadableStream, isResponse } from "../../javascript-utils/is-type.js";
+/**
+ * Returns an iterator that breaks its input into chunks and yields them one-by-one.
+ * @param data
+ * @param options
+ * @returns
+ * This function can e.g. be used to enable data sources that can only be read atomically
+ * (such as `Blob` and `File` via `FileReader`) to still be parsed in batches.
+ */
 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');
+    if (typeof data === 'string') {
+        // Note: Converts string chunks to binary
+        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/iterators/make-iterator/make-stream-iterator.js

@@ -1,32 +1,95 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { isBrowser, toArrayBuffer } from '@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
+ */
 export function makeStreamIterator(stream, options) {
-  return isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
+    return isBrowser
+        ? makeBrowserStreamIterator(stream, options)
+        : makeNodeStreamIterator(stream, options);
 }
+/**
+ * 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 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 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

@@ -1,4 +1,4 @@
-import type { IteratorOptions } from './make-iterator';
+import type { IteratorOptions } from "./make-iterator.js";
 /**
  * Returns an iterator that breaks a big string into chunks and yields them one-by-one as ArrayBuffers
  * @param blob string to iterate over

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

@@ -1 +1 @@
-{"version":3,"file":"make-string-iterator.d.ts","sourceRoot":"","sources":["../../../src/iterators/make-iterator/make-string-iterator.ts"],"names":[],"mappings":"AAIA,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"}
+{"version":3,"file":"make-string-iterator.d.ts","sourceRoot":"","sources":["../../../src/iterators/make-iterator/make-string-iterator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,eAAe,EAAC,2BAAwB;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,13 +1,23 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 const DEFAULT_CHUNK_SIZE = 256 * 1024;
+/**
+ * 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 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);
-  }
+    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

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

@@ -1,32 +1,50 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * Builds a DOM stream from an iterator
+ * This stream is currently used in browsers only,
+ * but note that Web stream support is present in Node from Node 16
+ * https://nodejs.org/api/webstreams.html#webstreams_web_streams_api
+ */
 export function makeStream(source, options) {
-  if (globalThis.loaders.makeNodeStream) {
-    return globalThis.loaders.makeNodeStream(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));
+    if (globalThis.loaders.makeNodeStream) {
+        return globalThis.loaders.makeNodeStream(source, options);
     }
-  }, {
-    highWaterMark: 2 ** 24,
-    ...options
-  });
+    // TODO - add AsyncGenerator to parameter types?
+    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-ignore
+        type: 'bytes',
+        async pull(controller) {
+            try {
+                const { done, value } = await iterator.next();
+                if (done) {
+                    controller.close();
+                }
+                else {
+                    // TODO - ignores controller.desiredSize
+                    // @ts-expect-error Unclear why value is not correctly typed
+                    controller.enqueue(new Uint8Array(value));
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        async cancel() {
+            await iterator?.return?.();
+        }
+    }, 
+    // options: QueingStrategy<Uint8Array>
+    {
+        // This is bytes, not chunks
+        highWaterMark: 2 ** 24,
+        ...options
+    });
 }
-//# sourceMappingURL=make-stream.js.map

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

@@ -1,19 +1,25 @@
-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 => Boolean(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
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+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) => Boolean(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;
+/** Check for Node.js `Buffer` without triggering bundler to include buffer polyfill */
+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));
+// Not implemented in Firefox: && isFunction(x.pipeTo)
+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);

package/dist/lib/api/encode-table.js

@@ -1,45 +1,50 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Copyright 2022 Foursquare Labs, Inc
+/* global TextEncoder, TextDecoder */
 import { concatenateArrayBuffers } from '@loaders.gl/loader-utils';
 export async function encodeTable(data, writer, options) {
-  if (writer.encode) {
-    return await writer.encode(data, options);
-  }
-  if (writer.encodeText) {
-    const text = await writer.encodeText(data, options);
-    return new TextEncoder().encode(text);
-  }
-  if (writer.encodeInBatches) {
-    const batches = encodeTableInBatches(data, writer, options);
-    const chunks = [];
-    for await (const batch of batches) {
-      chunks.push(batch);
+    if (writer.encode) {
+        return await writer.encode(data, options);
     }
-    return concatenateArrayBuffers(...chunks);
-  }
-  throw new Error('Writer could not encode data');
+    if (writer.encodeText) {
+        const text = await writer.encodeText(data, options);
+        return new TextEncoder().encode(text);
+    }
+    if (writer.encodeInBatches) {
+        // Create an iterator representing the data
+        // TODO - Assumes this is a table
+        const batches = encodeTableInBatches(data, writer, options);
+        // Concatenate the output
+        const chunks = [];
+        for await (const batch of batches) {
+            chunks.push(batch);
+        }
+        return concatenateArrayBuffers(...chunks);
+    }
+    throw new Error('Writer could not encode data');
 }
 export async function encodeTableAsText(data, writer, options) {
-  if (writer.text && writer.encodeText) {
-    return await writer.encodeText(data, options);
-  }
-  if (writer.text) {
-    const arrayBuffer = await encodeTable(data, writer, options);
-    return new TextDecoder().decode(arrayBuffer);
-  }
-  throw new Error(`Writer ${writer.name} could not encode data as text`);
+    if (writer.text && writer.encodeText) {
+        return await writer.encodeText(data, options);
+    }
+    if (writer.text) {
+        const arrayBuffer = await encodeTable(data, writer, options);
+        return new TextDecoder().decode(arrayBuffer);
+    }
+    throw new Error(`Writer ${writer.name} could not encode data as text`);
 }
 export function encodeTableInBatches(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');
+    if (writer.encodeInBatches) {
+        const dataIterator = getIterator(data);
+        // @ts-expect-error
+        return writer.encodeInBatches(dataIterator, options);
+    }
+    // TODO -fall back to atomic encode?
+    throw new Error('Writer could not encode data in batches');
 }
 function getIterator(data) {
-  const dataIterator = [{
-    ...data,
-    start: 0,
-    end: data.length
-  }];
-  return dataIterator;
+    const dataIterator = [{ ...data, start: 0, end: data.length }];
+    return dataIterator;
 }
-//# sourceMappingURL=encode-table.js.map

package/dist/lib/api/encode.js

@@ -1,98 +1,137 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { canEncodeWithWorker, NodeFile, resolvePath } from '@loaders.gl/loader-utils';
 import { processOnWorker } from '@loaders.gl/worker-utils';
 import { isBrowser } from '@loaders.gl/loader-utils';
 import { fetchFile } from "../fetch/fetch-file.js";
 import { getLoaderOptions } from "./loader-options.js";
+/**
+ * Encode loaded data into a binary ArrayBuffer using the specified Writer.
+ */
 export async function encode(data, writer, options) {
-  const globalOptions = getLoaderOptions();
-  options = {
-    ...globalOptions,
-    ...options
-  };
-  if (writer.encodeURLtoURL) {
-    return encodeWithCommandLineTool(writer, data, options);
-  }
-  if (canEncodeWithWorker(writer, options)) {
-    return await processOnWorker(writer, data, options);
-  }
-  return await writer.encode(data, options);
+    const globalOptions = getLoaderOptions();
+    // const globalOptions: WriterOptions = {}; // getWriterOptions();
+    options = { ...globalOptions, ...options };
+    // Handle the special case where we are invoking external command-line tools
+    if (writer.encodeURLtoURL) {
+        return encodeWithCommandLineTool(writer, data, options);
+    }
+    // Worker support
+    if (canEncodeWithWorker(writer, options)) {
+        return await processOnWorker(writer, data, options);
+    }
+    // TODO Merge default writer options with options argument like it is done in load module.
+    return await writer.encode(data, options);
 }
+/**
+ * Encode loaded data into a binary ArrayBuffer using the specified Writer.
+ */
 export function encodeSync(data, writer, options) {
-  if (writer.encodeSync) {
-    return writer.encodeSync(data, options);
-  }
-  if (writer.encodeTextSync) {
-    return new TextEncoder().encode(writer.encodeTextSync(data, options));
-  }
-  throw new Error(`Writer ${writer.name} could not synchronously encode data`);
+    if (writer.encodeSync) {
+        return writer.encodeSync(data, options);
+    }
+    if (writer.encodeTextSync) {
+        return new TextEncoder().encode(writer.encodeTextSync(data, options));
+    }
+    throw new Error(`Writer ${writer.name} could not synchronously encode data`);
 }
+/**
+ * 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 async function encodeText(data, writer, options) {
-  if (writer.encodeText) {
-    return await writer.encodeText(data, options);
-  }
-  if (writer.encodeTextSync) {
-    return writer.encodeTextSync(data, options);
-  }
-  if (writer.text) {
-    const arrayBuffer = await writer.encode(data, options);
-    return new TextDecoder().decode(arrayBuffer);
-  }
-  throw new Error(`Writer ${writer.name} could not encode data as text`);
+    if (writer.encodeText) {
+        return await writer.encodeText(data, options);
+    }
+    if (writer.encodeTextSync) {
+        return writer.encodeTextSync(data, options);
+    }
+    if (writer.text) {
+        const arrayBuffer = await writer.encode(data, options);
+        return new TextDecoder().decode(arrayBuffer);
+    }
+    throw new Error(`Writer ${writer.name} could not encode data as text`);
 }
+/**
+ * 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 function encodeTextSync(data, writer, options) {
-  if (writer.encodeTextSync) {
-    return writer.encodeTextSync(data, options);
-  }
-  if (writer.text && writer.encodeSync) {
-    const arrayBuffer = encodeSync(data, writer, options);
-    return new TextDecoder().decode(arrayBuffer);
-  }
-  throw new Error(`Writer ${writer.name} could not encode data as text`);
+    if (writer.encodeTextSync) {
+        return writer.encodeTextSync(data, options);
+    }
+    if (writer.text && writer.encodeSync) {
+        const arrayBuffer = encodeSync(data, writer, options);
+        return new TextDecoder().decode(arrayBuffer);
+    }
+    throw new Error(`Writer ${writer.name} could not encode data as text`);
 }
+/**
+ * Encode loaded data into a sequence (iterator) of binary ArrayBuffers using the specified Writer.
+ */
 export function encodeInBatches(data, writer, options) {
-  if (writer.encodeInBatches) {
-    const dataIterator = getIterator(data);
-    return writer.encodeInBatches(dataIterator, options);
-  }
-  throw new Error(`Writer ${writer.name} could not encode in batches`);
+    if (writer.encodeInBatches) {
+        const dataIterator = getIterator(data);
+        // @ts-expect-error
+        return writer.encodeInBatches(dataIterator, options);
+    }
+    // TODO -fall back to atomic encode?
+    throw new Error(`Writer ${writer.name} could not encode in batches`);
 }
+/**
+ * Encode loaded data into a sequence (iterator) of binary ArrayBuffers using the specified Writer.
+ */
 export function encodeTextInBatches(data, writer, options) {
-  if (writer.encodeTextInBatches) {
-    const dataIterator = getIterator(data);
-    return writer.encodeTextInBatches(dataIterator, options);
-  }
-  throw new Error(`Writer ${writer.name} could not encode text in batches`);
+    if (writer.encodeTextInBatches) {
+        const dataIterator = getIterator(data);
+        // @ts-expect-error
+        return writer.encodeTextInBatches(dataIterator, options);
+    }
+    // TODO -fall back to atomic encode?
+    throw new Error(`Writer ${writer.name} could not encode text in batches`);
 }
+/**
+ * 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 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;
+    inputUrl = resolvePath(inputUrl);
+    outputUrl = resolvePath(outputUrl);
+    if (isBrowser || !writer.encodeURLtoURL) {
+        throw new Error();
+    }
+    const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);
+    return outputFilename;
 }
+/** Helper function to encode via external tool (typically command line execution in Node.js) */
 async function encodeWithCommandLineTool(writer, data, options) {
-  if (isBrowser) {
-    throw new Error(`Writer ${writer.name} not supported in browser`);
-  }
-  const tmpInputFilename = getTemporaryFilename('input');
-  const file = new NodeFile(tmpInputFilename, 'w');
-  await file.write(data);
-  const tmpOutputFilename = getTemporaryFilename('output');
-  const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
-  const response = await fetchFile(outputFilename);
-  return response.arrayBuffer();
+    if (isBrowser) {
+        throw new Error(`Writer ${writer.name} not supported in browser`);
+    }
+    // TODO - how to generate filenames with correct extensions?
+    const tmpInputFilename = getTemporaryFilename('input');
+    const file = new NodeFile(tmpInputFilename, 'w');
+    await file.write(data);
+    const tmpOutputFilename = getTemporaryFilename('output');
+    const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
+    const response = await fetchFile(outputFilename);
+    return response.arrayBuffer();
 }
+/**
+ * @todo TODO - this is an unacceptable hack!!!
+ */
 function getIterator(data) {
-  const dataIterator = [{
-    ...data,
-    start: 0,
-    end: data.length
-  }];
-  return dataIterator;
+    const dataIterator = [{ ...data, start: 0, end: data.length }];
+    return dataIterator;
 }
+/**
+ * @todo Move to utils
+ */
 function getTemporaryFilename(filename) {
-  return `/tmp/${filename}`;
+    return `/tmp/${filename}`;
 }
-//# sourceMappingURL=encode.js.map