@loaders.gl/polyfills 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/filesystems/node-file.js

@@ -1,98 +1,130 @@
 import { resolvePath } from '@loaders.gl/loader-utils';
 import fs from 'fs';
 export class NodeFile {
-  constructor(path, flags, mode) {
-    this.handle = void 0;
-    this.size = void 0;
-    this.bigsize = void 0;
-    this.url = void 0;
-    path = resolvePath(path);
-    this.handle = fs.openSync(path, flags, mode);
-    const stats = fs.fstatSync(this.handle, {
-      bigint: true
-    });
-    this.size = Number(stats.size);
-    this.bigsize = stats.size;
-    this.url = path;
-  }
-  async close() {
-    return new Promise((resolve, reject) => {
-      fs.close(this.handle, err => err ? reject(err) : resolve());
-    });
-  }
-  async truncate(length) {
-    return new Promise((resolve, reject) => {
-      fs.ftruncate(this.handle, length, err => {
-        if (err) {
-          reject(err);
-        } else {
-          this.bigsize = BigInt(length);
-          this.size = Number(this.bigsize);
-          resolve();
+    constructor(path, flags, mode) {
+        path = resolvePath(path);
+        this.handle = fs.openSync(path, flags, mode);
+        const stats = fs.fstatSync(this.handle, { bigint: true });
+        this.size = Number(stats.size);
+        this.bigsize = stats.size;
+        this.url = path;
+    }
+    async close() {
+        return new Promise((resolve, reject) => {
+            fs.close(this.handle, (err) => (err ? reject(err) : resolve()));
+        });
+    }
+    async truncate(length) {
+        return new Promise((resolve, reject) => {
+            fs.ftruncate(this.handle, length, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    this.bigsize = BigInt(length);
+                    this.size = Number(this.bigsize);
+                    resolve();
+                }
+            });
+        });
+    }
+    async append(data) {
+        return new Promise((resolve, reject) => {
+            fs.appendFile(this.handle, data, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    this.bigsize = this.bigsize + BigInt(data.length);
+                    this.size = Number(this.bigsize);
+                    resolve();
+                }
+            });
+        });
+    }
+    async stat() {
+        return await new Promise((resolve, reject) => fs.fstat(this.handle, { bigint: true }, (err, info) => {
+            const stats = {
+                size: Number(info.size),
+                bigsize: info.size,
+                isDirectory: info.isDirectory()
+            };
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(stats);
+            }
+        }));
+    }
+    async read(offset, length) {
+        const arrayBuffer = new ArrayBuffer(length);
+        let bigOffset = BigInt(offset);
+        let totalBytesRead = 0;
+        const uint8Array = new Uint8Array(arrayBuffer);
+        let position;
+        // Read in loop until we get required number of bytes
+        while (length > 0) {
+            const bytesRead = await readBytes(this.handle, uint8Array, 0, length, bigOffset);
+            // Check if end of file reached
+            if (bytesRead === 0) {
+                break;
+            }
+            totalBytesRead += bytesRead;
+            bigOffset += BigInt(bytesRead);
+            length -= bytesRead;
+            // Advance position unless we are using built-in position advancement
+            if (position !== undefined) {
+                position += bytesRead;
+            }
         }
-      });
-    });
+        return totalBytesRead < length ? arrayBuffer.slice(0, totalBytesRead) : arrayBuffer;
+    }
+    async write(arrayBuffer, offset = 0, length = arrayBuffer.byteLength) {
+        return new Promise((resolve, reject) => {
+            // TODO - Node.js doesn't offer write with bigint offsets???
+            const nOffset = Number(offset);
+            const uint8Array = new Uint8Array(arrayBuffer, Number(offset), length);
+            fs.write(this.handle, uint8Array, 0, length, nOffset, (err, bytesWritten) => err ? reject(err) : resolve(bytesWritten));
+        });
+    }
+}
+async function readBytes(fd, uint8Array, offset, length, position) {
+    return await new Promise((resolve, reject) => fs.read(fd, uint8Array, offset, length, position, (err, bytesRead) => err ? reject(err) : resolve(bytesRead)));
+}
+// TODO - implement streaming write
+/*
+export interface WriteStreamOptions {
+  flags?: string;
+  encoding?: 'utf8';
+  fd?: number;
+  mode?: number;
+  autoClose?: boolean;
+  start?: number;
+}
+
+export class NodeStreamWritableFile implements WritableFile {
+  outputStream: fs.WriteStream | Writable;
+
+  constructor(pathOrStream: string | Writable, options?: WriteStreamOptions) {
+    this.outputStream =
+      typeof pathOrStream === 'string' ? fs.createWriteStream(pathOrStream, options) : pathOrStream;
   }
-  async append(data) {
+
+  async write(buffer: ArrayBuffer): Promise<void> {
     return new Promise((resolve, reject) => {
-      fs.appendFile(this.handle, data, err => {
-        if (err) {
-          reject(err);
-        } else {
-          this.bigsize = this.bigsize + BigInt(data.length);
-          this.size = Number(this.bigsize);
-          resolve();
-        }
-      });
+      const uint8Array = new Uint8Array(buffer);
+      this.outputStream.write(uint8Array, (err) => (err ? reject(err) : resolve()));
     });
   }
-  async stat() {
-    return await new Promise((resolve, reject) => fs.fstat(this.handle, {
-      bigint: true
-    }, (err, info) => {
-      const stats = {
-        size: Number(info.size),
-        bigsize: info.size,
-        isDirectory: info.isDirectory()
-      };
-      if (err) {
-        reject(err);
-      } else {
-        resolve(stats);
-      }
-    }));
-  }
-  async read(offset, length) {
-    const arrayBuffer = new ArrayBuffer(length);
-    let bigOffset = BigInt(offset);
-    let totalBytesRead = 0;
-    const uint8Array = new Uint8Array(arrayBuffer);
-    let position;
-    while (length > 0) {
-      const bytesRead = await readBytes(this.handle, uint8Array, 0, length, bigOffset);
-      if (bytesRead === 0) {
-        break;
-      }
-      totalBytesRead += bytesRead;
-      bigOffset += BigInt(bytesRead);
-      length -= bytesRead;
-      if (position !== undefined) {
-        position += bytesRead;
-      }
+
+  async close(): Promise<void> {
+    if (this.outputStream instanceof fs.WriteStream) {
+      return new Promise((resolve, reject) => {
+        const stream = this.outputStream as fs.WriteStream;
+        stream.close((err) => (err ? reject(err) : resolve()));
+      });
     }
-    return totalBytesRead < length ? arrayBuffer.slice(0, totalBytesRead) : arrayBuffer;
   }
-  async write(arrayBuffer) {
-    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let length = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : arrayBuffer.byteLength;
-    return new Promise((resolve, reject) => {
-      const nOffset = Number(offset);
-      const uint8Array = new Uint8Array(arrayBuffer, Number(offset), length);
-      fs.write(this.handle, uint8Array, 0, length, nOffset, (err, bytesWritten) => err ? reject(err) : resolve(bytesWritten));
-    });
-  }
-}
-async function readBytes(fd, uint8Array, offset, length, position) {
-  return await new Promise((resolve, reject) => fs.read(fd, uint8Array, offset, length, position, (err, bytesRead) => err ? reject(err) : resolve(bytesRead)));
 }
-//# sourceMappingURL=node-file.js.map
+*/

package/dist/filesystems/node-filesystem.d.ts

@@ -1,5 +1,5 @@
 import { Stat, RandomAccessFileSystem } from '@loaders.gl/loader-utils';
-import { NodeFile } from './node-file';
+import { NodeFile } from "./node-file.js";
 /**
  * FileSystem pass-through for Node.js
  * Compatible with BrowserFileSystem.

package/dist/filesystems/node-filesystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-filesystem.d.ts","sourceRoot":"","sources":["../../src/filesystems/node-filesystem.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,IAAI,EAAE,sBAAsB,EAAC,MAAM,0BAA0B,CAAC;AAEtE,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AAMrC;;;;GAIG;AACH,qBAAa,cAAe,YAAW,sBAAsB;IAC3D,QAAQ,EAAE,OAAO,CAAQ;IACzB,QAAQ,EAAE,OAAO,CAAQ;;IAKnB,OAAO,CAAC,OAAO,SAAM,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAIpD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASjC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAInC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAK5D,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,GAAS,GAAG,OAAO,CAAC,QAAQ,CAAC;IAInE,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,GAAG,GAAG,IAAU,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC;CAG7F"}
+{"version":3,"file":"node-filesystem.d.ts","sourceRoot":"","sources":["../../src/filesystems/node-filesystem.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,IAAI,EAAE,sBAAsB,EAAC,MAAM,0BAA0B,CAAC;AAEtE,OAAO,EAAC,QAAQ,EAAC,uBAAoB;AAMrC;;;;GAIG;AACH,qBAAa,cAAe,YAAW,sBAAsB;IAC3D,QAAQ,EAAE,OAAO,CAAQ;IACzB,QAAQ,EAAE,OAAO,CAAQ;;IAKnB,OAAO,CAAC,OAAO,SAAM,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAIpD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASjC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAInC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAK5D,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,GAAS,GAAG,OAAO,CAAC,QAAQ,CAAC;IAInE,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,GAAG,GAAG,IAAU,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC;CAG7F"}

package/dist/filesystems/node-filesystem.js

@@ -1,40 +1,44 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import fsPromise from 'fs/promises';
 import { NodeFile } from "./node-file.js";
 import { fetchNode } from "./fetch-node.js";
+// import {fetchFile} from "../fetch/fetch-file"
+// import {selectLoader} from "../api/select-loader";
+/**
+ * FileSystem pass-through for Node.js
+ * Compatible with BrowserFileSystem.
+ * @param options
+ */
 export class NodeFileSystem {
-  constructor() {
-    this.readable = true;
-    this.writable = true;
-  }
-  async readdir() {
-    let dirname = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '.';
-    let options = arguments.length > 1 ? arguments[1] : undefined;
-    return await fsPromise.readdir(dirname, options);
-  }
-  async stat(path) {
-    const info = await fsPromise.stat(path, {
-      bigint: true
-    });
-    return {
-      size: Number(info.size),
-      bigsize: info.size,
-      isDirectory: info.isDirectory()
-    };
-  }
-  async unlink(path) {
-    return await fsPromise.unlink(path);
-  }
-  async fetch(path, options) {
-    return await fetchNode(path, options);
-  }
-  async openReadableFile(path) {
-    let flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'r';
-    return new NodeFile(path, flags);
-  }
-  async openWritableFile(path) {
-    let flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'w';
-    let mode = arguments.length > 2 ? arguments[2] : undefined;
-    return new NodeFile(path, flags, mode);
-  }
+    // implements FileSystem
+    constructor() {
+        this.readable = true;
+        this.writable = true;
+    }
+    async readdir(dirname = '.', options) {
+        return await fsPromise.readdir(dirname, options);
+    }
+    async stat(path) {
+        const info = await fsPromise.stat(path, { bigint: true });
+        return {
+            size: Number(info.size),
+            bigsize: info.size,
+            isDirectory: info.isDirectory()
+        };
+    }
+    async unlink(path) {
+        return await fsPromise.unlink(path);
+    }
+    async fetch(path, options) {
+        return await fetchNode(path, options);
+    }
+    // implements IRandomAccessFileSystem
+    async openReadableFile(path, flags = 'r') {
+        return new NodeFile(path, flags);
+    }
+    async openWritableFile(path, flags = 'w', mode) {
+        return new NodeFile(path, flags, mode);
+    }
 }
-//# sourceMappingURL=node-filesystem.js.map

package/dist/filesystems/stream-utils.node.js

@@ -1,65 +1,98 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import zlib from 'zlib';
-const isArrayBuffer = x => x && x instanceof ArrayBuffer;
-const isBuffer = x => x && x instanceof Buffer;
+const isArrayBuffer = (x) => x && x instanceof ArrayBuffer;
+const isBuffer = (x) => x && x instanceof Buffer;
+/**
+ *
+ */
 export function decompressReadStream(readStream, headers) {
-  switch (headers === null || headers === void 0 ? void 0 : headers.get('content-encoding')) {
-    case 'br':
-      return readStream.pipe(zlib.createBrotliDecompress());
-    case 'gzip':
-      return readStream.pipe(zlib.createGunzip());
-    case 'deflate':
-      return readStream.pipe(zlib.createDeflate());
-    default:
-      return readStream;
-  }
+    switch (headers?.get('content-encoding')) {
+        case 'br':
+            return readStream.pipe(zlib.createBrotliDecompress());
+        case 'gzip':
+            return readStream.pipe(zlib.createGunzip());
+        case 'deflate':
+            return readStream.pipe(zlib.createDeflate());
+        default:
+            // No compression or an unknown one, just return it as is
+            return readStream;
+    }
 }
+/**
+ *
+ * @param readStream
+ * @returns
+ */
 export async function concatenateReadStream(readStream) {
-  const arrayBufferChunks = [];
-  return await new Promise((resolve, reject) => {
-    readStream.on('error', error => reject(error));
-    readStream.on('readable', () => readStream.read());
-    readStream.on('data', chunk => {
-      if (typeof chunk === 'string') {
-        reject(new Error('Read stream not binary'));
-      }
-      arrayBufferChunks.push(toArrayBuffer(chunk));
+    const arrayBufferChunks = [];
+    return await new Promise((resolve, reject) => {
+        readStream.on('error', (error) => reject(error));
+        // Once the readable callback has been added, stream switches to "flowing mode"
+        // In Node 10 (but not 12 and 14) this causes `data` and `end` to never be called unless we read data here
+        readStream.on('readable', () => readStream.read());
+        readStream.on('data', (chunk) => {
+            if (typeof chunk === 'string') {
+                reject(new Error('Read stream not binary'));
+            }
+            arrayBufferChunks.push(toArrayBuffer(chunk));
+        });
+        readStream.on('end', () => {
+            const arrayBuffer = concatenateArrayBuffers(arrayBufferChunks);
+            resolve(arrayBuffer);
+        });
     });
-    readStream.on('end', () => {
-      const arrayBuffer = concatenateArrayBuffers(arrayBufferChunks);
-      resolve(arrayBuffer);
-    });
-  });
 }
+/**
+ * Concatenate a sequence of ArrayBuffers
+ * @return A concatenated ArrayBuffer
+ * @note duplicates loader-utils since polyfills should be independent
+ */
 export function concatenateArrayBuffers(sources) {
-  const sourceArrays = sources.map(source2 => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
-  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
-  const result = new Uint8Array(byteLength);
-  let offset = 0;
-  for (const sourceArray of sourceArrays) {
-    result.set(sourceArray, offset);
-    offset += sourceArray.byteLength;
-  }
-  return result.buffer;
+    // Make sure all inputs are wrapped in typed arrays
+    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+    // Get length of all inputs
+    const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+    // Allocate array with space for all inputs
+    const result = new Uint8Array(byteLength);
+    // Copy the subarrays
+    let offset = 0;
+    for (const sourceArray of sourceArrays) {
+        result.set(sourceArray, offset);
+        offset += sourceArray.byteLength;
+    }
+    // We work with ArrayBuffers, discard the typed array wrapper
+    return result.buffer;
 }
+/**
+ * @param data
+ * @todo Duplicate of core
+ */
 export function toArrayBuffer(data) {
-  if (isArrayBuffer(data)) {
-    return data;
-  }
-  if (isBuffer(data)) {
-    const typedArray = new Uint8Array(data);
-    return typedArray.buffer;
-  }
-  if (ArrayBuffer.isView(data)) {
-    return data.buffer;
-  }
-  if (typeof data === 'string') {
-    const text = data;
-    const uint8Array = new TextEncoder().encode(text);
-    return uint8Array.buffer;
-  }
-  if (data && typeof data === 'object' && data._toArrayBuffer) {
-    return data._toArrayBuffer();
-  }
-  throw new Error(`toArrayBuffer(${JSON.stringify(data, null, 2).slice(10)})`);
+    if (isArrayBuffer(data)) {
+        return data;
+    }
+    // TODO - per docs we should just be able to call buffer.buffer, but there are issues
+    if (isBuffer(data)) {
+        // @ts-expect-error
+        const typedArray = new Uint8Array(data);
+        return typedArray.buffer;
+    }
+    // Careful - Node Buffers will look like ArrayBuffers (keep after isBuffer)
+    if (ArrayBuffer.isView(data)) {
+        return data.buffer;
+    }
+    if (typeof data === 'string') {
+        const text = data;
+        const uint8Array = new TextEncoder().encode(text);
+        return uint8Array.buffer;
+    }
+    // HACK to support Blob polyfill
+    // @ts-expect-error
+    if (data && typeof data === 'object' && data._toArrayBuffer) {
+        // @ts-expect-error
+        return data._toArrayBuffer();
+    }
+    throw new Error(`toArrayBuffer(${JSON.stringify(data, null, 2).slice(10)})`);
 }
-//# sourceMappingURL=stream-utils.node.js.map

package/dist/images/encode-image-node.js

@@ -1,20 +1,33 @@
+// Use stackgl modules for DOM-less reading and writing of images
 import savePixels from 'save-pixels';
 import ndarray from 'ndarray';
 import { bufferToArrayBuffer } from "../buffer/to-array-buffer.node.js";
+/**
+ * Returns data bytes representing a compressed image in PNG or JPG format,
+ * This data can be saved using file system (f) methods or
+ * used in a request.
+ * @param image to save
+ * @param options
+ * @param options.type='png' - png, jpg or image/png, image/jpg are valid
+ * @param options.dataURI - Whether to include a data URI header
+ * @return {*} bytes
+ */
 export function encodeImageToStreamNode(image, options) {
-  const type = options.type ? options.type.replace('image/', '') : 'jpeg';
-  const pixels = ndarray(image.data, [image.width, image.height, 4], [4, image.width * 4, 1], 0);
-  return savePixels(pixels, type, options);
+    // Support MIME type strings
+    const type = options.type ? options.type.replace('image/', '') : 'jpeg';
+    const pixels = ndarray(image.data, [image.width, image.height, 4], [4, image.width * 4, 1], 0);
+    // Note: savePixels returns a stream
+    return savePixels(pixels, type, options);
 }
 export function encodeImageNode(image, options) {
-  const imageStream = encodeImageToStreamNode(image, options);
-  return new Promise(resolve => {
-    const buffers = [];
-    imageStream.on('data', buffer => buffers.push(buffer));
-    imageStream.on('end', () => {
-      const buffer = Buffer.concat(buffers);
-      resolve(bufferToArrayBuffer(buffer));
+    const imageStream = encodeImageToStreamNode(image, options);
+    return new Promise((resolve) => {
+        const buffers = [];
+        imageStream.on('data', (buffer) => buffers.push(buffer));
+        // TODO - convert to arraybuffer?
+        imageStream.on('end', () => {
+            const buffer = Buffer.concat(buffers);
+            resolve(bufferToArrayBuffer(buffer));
+        });
     });
-  });
 }
-//# sourceMappingURL=encode-image-node.js.map

package/dist/images/encode-image.node.js

@@ -1,20 +1,33 @@
+// Use stackgl modules for DOM-less reading and writing of images
 import savePixels from 'save-pixels';
 import ndarray from 'ndarray';
 import { bufferToArrayBuffer } from "../buffer/to-array-buffer.node.js";
+/**
+ * Returns data bytes representing a compressed image in PNG or JPG format,
+ * This data can be saved using file system (f) methods or
+ * used in a request.
+ * @param image to save
+ * @param options
+ * @param options.type='png' - png, jpg or image/png, image/jpg are valid
+ * @param options.dataURI - Whether to include a data URI header
+ * @return {*} bytes
+ */
 export function encodeImageToStreamNode(image, options) {
-  const type = options.type ? options.type.replace('image/', '') : 'jpeg';
-  const pixels = ndarray(image.data, [image.width, image.height, 4], [4, image.width * 4, 1], 0);
-  return savePixels(pixels, type, options);
+    // Support MIME type strings
+    const type = options.type ? options.type.replace('image/', '') : 'jpeg';
+    const pixels = ndarray(image.data, [image.width, image.height, 4], [4, image.width * 4, 1], 0);
+    // Note: savePixels returns a stream
+    return savePixels(pixels, type, options);
 }
 export function encodeImageNode(image, options) {
-  const imageStream = encodeImageToStreamNode(image, options);
-  return new Promise(resolve => {
-    const buffers = [];
-    imageStream.on('data', buffer => buffers.push(buffer));
-    imageStream.on('end', () => {
-      const buffer = Buffer.concat(buffers);
-      resolve(bufferToArrayBuffer(buffer));
+    const imageStream = encodeImageToStreamNode(image, options);
+    return new Promise((resolve) => {
+        const buffers = [];
+        imageStream.on('data', (buffer) => buffers.push(buffer));
+        // TODO - convert to arraybuffer?
+        imageStream.on('end', () => {
+            const buffer = Buffer.concat(buffers);
+            resolve(bufferToArrayBuffer(buffer));
+        });
     });
-  });
 }
-//# sourceMappingURL=encode-image.node.js.map

package/dist/images/parse-image-node.js

@@ -1,29 +1,36 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import getPixels from 'get-pixels';
+/** Declares which image format mime types this loader polyfill supports */
 export const NODE_FORMAT_SUPPORT = ['image/png', 'image/jpeg', 'image/gif'];
 export async function parseImageNode(arrayBuffer, mimeType) {
-  if (!mimeType) {
-    throw new Error('MIMEType is required to parse image under Node.js');
-  }
-  const buffer = arrayBuffer instanceof Buffer ? arrayBuffer : Buffer.from(arrayBuffer);
-  const ndarray = await getPixelsAsync(buffer, mimeType);
-  return ndarray;
+    if (!mimeType) {
+        throw new Error('MIMEType is required to parse image under Node.js');
+    }
+    const buffer = arrayBuffer instanceof Buffer ? arrayBuffer : Buffer.from(arrayBuffer);
+    const ndarray = await getPixelsAsync(buffer, mimeType);
+    return ndarray;
 }
+// TODO - check if getPixels callback is asynchronous if provided with buffer input
+// if not, parseImage can be a sync function
 function getPixelsAsync(buffer, mimeType) {
-  return new Promise(resolve => getPixels(buffer, mimeType, (err, ndarray) => {
-    if (err) {
-      throw err;
-    }
-    const shape = [...ndarray.shape];
-    const layers = ndarray.shape.length === 4 ? ndarray.shape.shift() : 1;
-    const data = ndarray.data instanceof Buffer ? new Uint8Array(ndarray.data) : ndarray.data;
-    resolve({
-      shape,
-      data,
-      width: ndarray.shape[0],
-      height: ndarray.shape[1],
-      components: ndarray.shape[2],
-      layers: layers ? [layers] : []
-    });
-  }));
+    return new Promise((resolve) => getPixels(buffer, mimeType, (err, ndarray) => {
+        if (err) {
+            throw err;
+        }
+        const shape = [...ndarray.shape];
+        const layers = ndarray.shape.length === 4 ? ndarray.shape.shift() : 1;
+        const data = ndarray.data instanceof Buffer ? new Uint8Array(ndarray.data) : ndarray.data;
+        // extract width/height etc
+        resolve({
+            shape,
+            data,
+            width: ndarray.shape[0],
+            height: ndarray.shape[1],
+            components: ndarray.shape[2],
+            // TODO - error
+            layers: layers ? [layers] : []
+        });
+    }));
 }
-//# sourceMappingURL=parse-image-node.js.map