@loaders.gl/loader-utils 3.0.10 → 3.0.14

package/dist/es5/index.js

@@ -235,6 +235,12 @@ Object.defineProperty(exports, "_addAliases", {
     return _fileAliases.addAliases;
   }
 });
+Object.defineProperty(exports, "JSONLoader", {
+  enumerable: true,
+  get: function get() {
+    return _jsonLoader.JSONLoader;
+  }
+});
 Object.defineProperty(exports, "isBuffer", {
   enumerable: true,
   get: function get() {
@@ -253,13 +259,19 @@ Object.defineProperty(exports, "bufferToArrayBuffer", {
     return _bufferUtils.bufferToArrayBuffer;
   }
 });
-Object.defineProperty(exports, "JSONLoader", {
+Object.defineProperty(exports, "promisify", {
   enumerable: true,
   get: function get() {
-    return _jsonLoader.JSONLoader;
+    return util.promisify;
+  }
+});
+Object.defineProperty(exports, "_NodeFileSystem", {
+  enumerable: true,
+  get: function get() {
+    return _nodeFilesystem.default;
   }
 });
-exports.fs = exports.path = void 0;
+exports.fs = exports.util = exports.path = void 0;
 
 var _assert = require("./lib/env-utils/assert");
 
@@ -287,19 +299,25 @@ var _asyncIteration = require("./lib/iterators/async-iteration");
 
 var _requestScheduler = _interopRequireDefault(require("./lib/request-utils/request-scheduler"));
 
+var _fileAliases = require("./lib/path-utils/file-aliases");
+
+var _jsonLoader = require("./json-loader");
+
 var path = _interopRequireWildcard(require("./lib/path-utils/path"));
 
 exports.path = path;
 
-var _fileAliases = require("./lib/path-utils/file-aliases");
+var _bufferUtils = require("./lib/binary-utils/buffer-utils");
+
+var util = _interopRequireWildcard(require("./lib/node/util"));
+
+exports.util = util;
 
 var fs = _interopRequireWildcard(require("./lib/node/fs"));
 
 exports.fs = fs;
 
-var _bufferUtils = require("./lib/binary-utils/buffer-utils");
-
-var _jsonLoader = require("./json-loader");
+var _nodeFilesystem = _interopRequireDefault(require("./lib/filesystems/node-filesystem"));
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA;;AACA;;AAWA;;AACA;;AAGA;;AAGA;;AAOA;;AACA;;AAIA;;AAKA;;AAGA;;AAMA;;AAGA;;AAGA;;;;AAEA;;AAIA;;;;AAIA;;AAEA","sourcesContent":["// TYPES\nexport type {\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions,\n  Writer,\n  WriterOptions,\n  DataType,\n  SyncDataType,\n  BatchableDataType,\n  IFileSystem,\n  IRandomAccessReadFileSystem\n} from './types';\n\n// GENERAL UTILS\nexport {assert} from './lib/env-utils/assert';\nexport {\n  isBrowser,\n  isWorker,\n  nodeVersion,\n  self,\n  window,\n  global,\n  document\n} from './lib/env-utils/globals';\n\n// LOADERS.GL-SPECIFIC WORKER UTILS\nexport {createLoaderWorker} from './lib/worker-loader-utils/create-loader-worker';\nexport {parseWithWorker, canParseWithWorker} from './lib/worker-loader-utils/parse-with-worker';\n\n// PARSER UTILS\nexport {parseJSON} from './lib/parser-utils/parse-json';\n\n// MEMORY COPY UTILS\nexport {\n  toArrayBuffer,\n  sliceArrayBuffer,\n  concatenateArrayBuffers,\n  concatenateTypedArrays,\n  compareArrayBuffers\n} from './lib/binary-utils/array-buffer-utils';\nexport {padToNBytes, copyToArray, copyArrayBuffer} from './lib/binary-utils/memory-copy-utils';\nexport {\n  copyPaddedArrayBufferToDataView,\n  copyPaddedStringToDataView\n} from './lib/binary-utils/binary-copy-utils';\nexport {\n  padStringToByteAlignment,\n  copyStringToDataView,\n  copyBinaryToDataView\n} from './lib/binary-utils/encode-utils';\nexport {getFirstCharacters, getMagicString} from './lib/binary-utils/get-first-characters';\n\n// ITERATOR UTILS\nexport {\n  makeTextEncoderIterator,\n  makeTextDecoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from './lib/iterators/text-iterators';\nexport {forEach, concatenateArrayBuffersAsync} from './lib/iterators/async-iteration';\n\n// REQUEST UTILS\nexport {default as RequestScheduler} from './lib/request-utils/request-scheduler';\n\n// NODE `path`` REPLACEMENT\nimport * as path from './lib/path-utils/path';\nexport {path};\nexport {setPathPrefix, getPathPrefix, resolvePath} from './lib/path-utils/file-aliases';\nexport {addAliases as _addAliases} from './lib/path-utils/file-aliases';\n\n// NODE `fs` WRAPPERS\nimport * as fs from './lib/node/fs';\nexport {fs};\n\n// NODE `buffer` WRAPPERS\nexport {isBuffer, toBuffer, bufferToArrayBuffer} from './lib/binary-utils/buffer-utils';\n\nexport {JSONLoader} from './json-loader';\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA;;AACA;;AAWA;;AACA;;AAGA;;AAGA;;AAOA;;AACA;;AAIA;;AAKA;;AAGA;;AAMA;;AAGA;;AAGA;;AAIA;;AAOA;;;;AAIA;;AAKA;;;;AAMA;;;;AAIA","sourcesContent":["// TYPES\nexport type {\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions,\n  Writer,\n  WriterOptions,\n  DataType,\n  SyncDataType,\n  BatchableDataType,\n  IFileSystem,\n  IRandomAccessReadFileSystem\n} from './types';\n\n// GENERAL UTILS\nexport {assert} from './lib/env-utils/assert';\nexport {\n  isBrowser,\n  isWorker,\n  nodeVersion,\n  self,\n  window,\n  global,\n  document\n} from './lib/env-utils/globals';\n\n// LOADERS.GL-SPECIFIC WORKER UTILS\nexport {createLoaderWorker} from './lib/worker-loader-utils/create-loader-worker';\nexport {parseWithWorker, canParseWithWorker} from './lib/worker-loader-utils/parse-with-worker';\n\n// PARSER UTILS\nexport {parseJSON} from './lib/parser-utils/parse-json';\n\n// MEMORY COPY UTILS\nexport {\n  toArrayBuffer,\n  sliceArrayBuffer,\n  concatenateArrayBuffers,\n  concatenateTypedArrays,\n  compareArrayBuffers\n} from './lib/binary-utils/array-buffer-utils';\nexport {padToNBytes, copyToArray, copyArrayBuffer} from './lib/binary-utils/memory-copy-utils';\nexport {\n  copyPaddedArrayBufferToDataView,\n  copyPaddedStringToDataView\n} from './lib/binary-utils/binary-copy-utils';\nexport {\n  padStringToByteAlignment,\n  copyStringToDataView,\n  copyBinaryToDataView\n} from './lib/binary-utils/encode-utils';\nexport {getFirstCharacters, getMagicString} from './lib/binary-utils/get-first-characters';\n\n// ITERATOR UTILS\nexport {\n  makeTextEncoderIterator,\n  makeTextDecoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from './lib/iterators/text-iterators';\nexport {forEach, concatenateArrayBuffersAsync} from './lib/iterators/async-iteration';\n\n// REQUEST UTILS\nexport {default as RequestScheduler} from './lib/request-utils/request-scheduler';\n\n// PATH HELPERS\nexport {setPathPrefix, getPathPrefix, resolvePath} from './lib/path-utils/file-aliases';\nexport {addAliases as _addAliases} from './lib/path-utils/file-aliases';\n\n// MICRO LOADERS\nexport {JSONLoader} from './json-loader';\n\n// NODE support\n\n// Node.js emulation (can be used in browser)\n\n// `path` replacement (avoids bundling big path polyfill)\nimport * as path from './lib/path-utils/path';\nexport {path};\n\n// Avoid direct use of `Buffer` which pulls in 50KB polyfill\nexport {isBuffer, toBuffer, bufferToArrayBuffer} from './lib/binary-utils/buffer-utils';\n\n// Note.js wrappers (can be safely imported, but not used in browser)\n\n// Use instead of importing 'util'\nimport * as util from './lib/node/util';\nexport {util};\n// TODO - remove\nexport {promisify} from './lib/node/util';\n\n// Use instead of importing 'fs';`\nimport * as fs from './lib/node/fs';\nexport {fs};\n\n// EXPERIMENTAL\nexport {default as _NodeFileSystem} from './lib/filesystems/node-filesystem';\n"],"file":"index.js"}

package/dist/es5/json-loader.js

@@ -11,7 +11,7 @@ var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"))
 
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 
-var VERSION = typeof "3.0.10" !== 'undefined' ? "3.0.10" : 'latest';
+var VERSION = typeof "3.0.14" !== 'undefined' ? "3.0.14" : 'latest';
 var JSONLoader = {
   name: 'JSON',
   id: 'json',

package/dist/es5/lib/binary-utils/array-buffer-utils.js

@@ -15,7 +15,7 @@ exports.sliceArrayBuffer = sliceArrayBuffer;
 
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
-var node = _interopRequireWildcard(require("../node/buffer-utils.node"));
+var node = _interopRequireWildcard(require("./buffer-utils"));
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
@@ -28,8 +28,8 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
 function toArrayBuffer(data) {
-  if (node.toArrayBuffer) {
-    data = node.toArrayBuffer(data);
+  if (node.isBuffer(data)) {
+    data = node.bufferToArrayBuffer(data);
   }
 
   if (data instanceof ArrayBuffer) {
@@ -37,7 +37,11 @@ function toArrayBuffer(data) {
   }
 
   if (ArrayBuffer.isView(data)) {
-    return data.buffer;
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+      return data.buffer;
+    }
+
+    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
   }
 
   if (typeof data === 'string') {

package/dist/es5/lib/binary-utils/array-buffer-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/binary-utils/array-buffer-utils.ts"],"names":["toArrayBuffer","data","node","ArrayBuffer","isView","buffer","text","uint8Array","TextEncoder","encode","_toArrayBuffer","Error","compareArrayBuffers","arrayBuffer1","arrayBuffer2","byteLength","array1","Uint8Array","array2","i","length","concatenateArrayBuffers","sources","sourceArrays","map","source2","reduce","typedArray","result","offset","sourceArray","set","concatenateTypedArrays","typedArrays","arrays","TypedArrayConstructor","constructor","sumLength","acc","value","array","sliceArrayBuffer","arrayBuffer","byteOffset","subArray","undefined","subarray","arrayCopy"],"mappings":";;;;;;;;;;;;;;;;;AACA;;;;;;;;;;;;AAKO,SAASA,aAAT,CAAuBC,IAAvB,EAA+C;AAEpD,MAAIC,IAAI,CAACF,aAAT,EAAwB;AAEtBC,IAAAA,IAAI,GAAGC,IAAI,CAACF,aAAL,CAAmBC,IAAnB,CAAP;AACD;;AAED,MAAIA,IAAI,YAAYE,WAApB,EAAiC;AAC/B,WAAOF,IAAP;AACD;;AAGD,MAAIE,WAAW,CAACC,MAAZ,CAAmBH,IAAnB,CAAJ,EAA8B;AAC5B,WAAOA,IAAI,CAACI,MAAZ;AACD;;AAED,MAAI,OAAOJ,IAAP,KAAgB,QAApB,EAA8B;AAC5B,QAAMK,IAAI,GAAGL,IAAb;AACA,QAAMM,UAAU,GAAG,IAAIC,WAAJ,GAAkBC,MAAlB,CAAyBH,IAAzB,CAAnB;AACA,WAAOC,UAAU,CAACF,MAAlB;AACD;;AAGD,MAAIJ,IAAI,IAAI,sBAAOA,IAAP,MAAgB,QAAxB,IAAoCA,IAAI,CAACS,cAA7C,EAA6D;AAC3D,WAAOT,IAAI,CAACS,cAAL,EAAP;AACD;;AAED,QAAM,IAAIC,KAAJ,CAAU,eAAV,CAAN;AACD;;AAQM,SAASC,mBAAT,CACLC,YADK,EAELC,YAFK,EAGLC,UAHK,EAII;AACTA,EAAAA,UAAU,GAAGA,UAAU,IAAIF,YAAY,CAACE,UAAxC;;AACA,MAAIF,YAAY,CAACE,UAAb,GAA0BA,UAA1B,IAAwCD,YAAY,CAACC,UAAb,GAA0BA,UAAtE,EAAkF;AAChF,WAAO,KAAP;AACD;;AACD,MAAMC,MAAM,GAAG,IAAIC,UAAJ,CAAeJ,YAAf,CAAf;AACA,MAAMK,MAAM,GAAG,IAAID,UAAJ,CAAeH,YAAf,CAAf;;AACA,OAAK,IAAIK,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,MAAM,CAACI,MAA3B,EAAmC,EAAED,CAArC,EAAwC;AACtC,QAAIH,MAAM,CAACG,CAAD,CAAN,KAAcD,MAAM,CAACC,CAAD,CAAxB,EAA6B;AAC3B,aAAO,KAAP;AACD;AACF;;AACD,SAAO,IAAP;AACD;;AAMM,SAASE,uBAAT,GAAwF;AAAA,oCAApDC,OAAoD;AAApDA,IAAAA,OAAoD;AAAA;;AAE7F,MAAMC,YAAY,GAAGD,OAAO,CAACE,GAAR,CAAY,UAACC,OAAD;AAAA,WAC/BA,OAAO,YAAYtB,WAAnB,GAAiC,IAAIc,UAAJ,CAAeQ,OAAf,CAAjC,GAA2DA,OAD5B;AAAA,GAAZ,CAArB;AAKA,MAAMV,UAAU,GAAGQ,YAAY,CAACG,MAAb,CAAoB,UAACN,MAAD,EAASO,UAAT;AAAA,WAAwBP,MAAM,GAAGO,UAAU,CAACZ,UAA5C;AAAA,GAApB,EAA4E,CAA5E,CAAnB;AAGA,MAAMa,MAAM,GAAG,IAAIX,UAAJ,CAAeF,UAAf,CAAf;AAGA,MAAIc,MAAM,GAAG,CAAb;;AAb6F,6CAcnEN,YAdmE;AAAA;;AAAA;AAc7F,wDAAwC;AAAA,UAA7BO,WAA6B;AACtCF,MAAAA,MAAM,CAACG,GAAP,CAAWD,WAAX,EAAwBD,MAAxB;AACAA,MAAAA,MAAM,IAAIC,WAAW,CAACf,UAAtB;AACD;AAjB4F;AAAA;AAAA;AAAA;AAAA;;AAoB7F,SAAOa,MAAM,CAACvB,MAAd;AACD;;AAQM,SAAS2B,sBAAT,GAA2D;AAAA,qCAArBC,WAAqB;AAArBA,IAAAA,WAAqB;AAAA;;AAEhE,MAAMC,MAAM,GAAGD,WAAf;AAEA,MAAME,qBAAqB,GAAID,MAAM,IAAIA,MAAM,CAACd,MAAP,GAAgB,CAA1B,IAA+Bc,MAAM,CAAC,CAAD,CAAN,CAAUE,WAA1C,IAA0D,IAAxF;;AACA,MAAI,CAACD,qBAAL,EAA4B;AAC1B,UAAM,IAAIxB,KAAJ,CACJ,sGADI,CAAN;AAGD;;AAED,MAAM0B,SAAS,GAAGH,MAAM,CAACR,MAAP,CAAc,UAACY,GAAD,EAAMC,KAAN;AAAA,WAAgBD,GAAG,GAAGC,KAAK,CAACnB,MAA5B;AAAA,GAAd,EAAkD,CAAlD,CAAlB;AAEA,MAAMQ,MAAM,GAAG,IAAIO,qBAAJ,CAA0BE,SAA1B,CAAf;AACA,MAAIR,MAAM,GAAG,CAAb;;AACA,6BAAoBK,MAApB,6BAA4B;AAAvB,QAAMM,KAAK,cAAX;AACHZ,IAAAA,MAAM,CAACG,GAAP,CAAWS,KAAX,EAAkBX,MAAlB;AACAA,IAAAA,MAAM,IAAIW,KAAK,CAACpB,MAAhB;AACD;;AACD,SAAOQ,MAAP;AACD;;AAQM,SAASa,gBAAT,CACLC,WADK,EAELC,UAFK,EAGL5B,UAHK,EAIQ;AACb,MAAM6B,QAAQ,GACZ7B,UAAU,KAAK8B,SAAf,GACI,IAAI5B,UAAJ,CAAeyB,WAAf,EAA4BI,QAA5B,CAAqCH,UAArC,EAAiDA,UAAU,GAAG5B,UAA9D,CADJ,GAEI,IAAIE,UAAJ,CAAeyB,WAAf,EAA4BI,QAA5B,CAAqCH,UAArC,CAHN;AAIA,MAAMI,SAAS,GAAG,IAAI9B,UAAJ,CAAe2B,QAAf,CAAlB;AACA,SAAOG,SAAS,CAAC1C,MAAjB;AACD","sourcesContent":["import {TypedArray} from '../../types';\nimport * as node from '../node/buffer-utils.node';\n\n/**\n * Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: any): ArrayBuffer {\n  // Note: Should be called first, Buffers can trigger other detections below\n  if (node.toArrayBuffer) {\n    // TODO - per docs we should just be able to call buffer.buffer, but there are issues\n    data = node.toArrayBuffer(data);\n  }\n\n  if (data instanceof ArrayBuffer) {\n    return data;\n  }\n\n  // Careful - Node Buffers will look like ArrayBuffers (keep after isBuffer)\n  if (ArrayBuffer.isView(data)) {\n    return data.buffer;\n  }\n\n  if (typeof data === 'string') {\n    const text = data;\n    const uint8Array = new TextEncoder().encode(text);\n    return uint8Array.buffer;\n  }\n\n  // HACK to support Blob polyfill\n  if (data && typeof data === 'object' && data._toArrayBuffer) {\n    return data._toArrayBuffer();\n  }\n\n  throw new Error('toArrayBuffer');\n}\n\n/**\n * compare two binary arrays for equality\n * @param {ArrayBuffer} a\n * @param {ArrayBuffer} b\n * @param {number} byteLength\n */\nexport function compareArrayBuffers(\n  arrayBuffer1: ArrayBuffer,\n  arrayBuffer2: ArrayBuffer,\n  byteLength?: number\n): boolean {\n  byteLength = byteLength || arrayBuffer1.byteLength;\n  if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {\n    return false;\n  }\n  const array1 = new Uint8Array(arrayBuffer1);\n  const array2 = new Uint8Array(arrayBuffer2);\n  for (let i = 0; i < array1.length; ++i) {\n    if (array1[i] !== array2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Concatenate a sequence of ArrayBuffers\n * @return A concatenated ArrayBuffer\n */\nexport function concatenateArrayBuffers(...sources: (ArrayBuffer | Uint8Array)[]): ArrayBuffer {\n  // Make sure all inputs are wrapped in typed arrays\n  const sourceArrays = sources.map((source2) =>\n    source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2\n  );\n\n  // Get length of all inputs\n  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);\n\n  // Allocate array with space for all inputs\n  const result = new Uint8Array(byteLength);\n\n  // Copy the subarrays\n  let offset = 0;\n  for (const sourceArray of sourceArrays) {\n    result.set(sourceArray, offset);\n    offset += sourceArray.byteLength;\n  }\n\n  // We work with ArrayBuffers, discard the typed array wrapper\n  return result.buffer;\n}\n\n/**\n * Concatenate arbitrary count of typed arrays\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays\n * @param {...*} arrays - list of arrays. All arrays should be the same type\n * @return A concatenated TypedArray\n */\nexport function concatenateTypedArrays<T>(...typedArrays: T[]): T {\n  // @ts-ignore\n  const arrays = typedArrays as TypedArray[];\n  // @ts-ignore\n  const TypedArrayConstructor = (arrays && arrays.length > 1 && arrays[0].constructor) || null;\n  if (!TypedArrayConstructor) {\n    throw new Error(\n      '\"concatenateTypedArrays\" - incorrect quantity of arguments or arguments have incompatible data types'\n    );\n  }\n\n  const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);\n  // @ts-ignore typescript does not like dynamic constructors\n  const result = new TypedArrayConstructor(sumLength);\n  let offset = 0;\n  for (const array of arrays) {\n    result.set(array, offset);\n    offset += array.length;\n  }\n  return result;\n}\n\n/**\n * Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0\n * @param arrayBuffer\n * @param byteOffset\n * @param byteLength\n */\nexport function sliceArrayBuffer(\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number,\n  byteLength?: number\n): ArrayBuffer {\n  const subArray =\n    byteLength !== undefined\n      ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength)\n      : new Uint8Array(arrayBuffer).subarray(byteOffset);\n  const arrayCopy = new Uint8Array(subArray);\n  return arrayCopy.buffer;\n}\n"],"file":"array-buffer-utils.js"}
+{"version":3,"sources":["../../../../src/lib/binary-utils/array-buffer-utils.ts"],"names":["toArrayBuffer","data","node","isBuffer","bufferToArrayBuffer","ArrayBuffer","isView","byteOffset","byteLength","buffer","slice","text","uint8Array","TextEncoder","encode","_toArrayBuffer","Error","compareArrayBuffers","arrayBuffer1","arrayBuffer2","array1","Uint8Array","array2","i","length","concatenateArrayBuffers","sources","sourceArrays","map","source2","reduce","typedArray","result","offset","sourceArray","set","concatenateTypedArrays","typedArrays","arrays","TypedArrayConstructor","constructor","sumLength","acc","value","array","sliceArrayBuffer","arrayBuffer","subArray","undefined","subarray","arrayCopy"],"mappings":"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","sourcesContent":["import {TypedArray} from '../../types';\nimport * as node from './buffer-utils';\n\n/**\n * Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: any): ArrayBuffer {\n  // Note: Should be called first, Buffers can trigger other detections below\n  if (node.isBuffer(data)) {\n    // TODO - per docs we should just be able to call buffer.buffer, but there are issues\n    data = node.bufferToArrayBuffer(data);\n  }\n\n  if (data instanceof ArrayBuffer) {\n    return data;\n  }\n\n  // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)\n  if (ArrayBuffer.isView(data)) {\n    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {\n      return data.buffer;\n    }\n    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);\n  }\n\n  if (typeof data === 'string') {\n    const text = data;\n    const uint8Array = new TextEncoder().encode(text);\n    return uint8Array.buffer;\n  }\n\n  // HACK to support Blob polyfill\n  if (data && typeof data === 'object' && data._toArrayBuffer) {\n    return data._toArrayBuffer();\n  }\n\n  throw new Error('toArrayBuffer');\n}\n\n/**\n * compare two binary arrays for equality\n * @param {ArrayBuffer} a\n * @param {ArrayBuffer} b\n * @param {number} byteLength\n */\nexport function compareArrayBuffers(\n  arrayBuffer1: ArrayBuffer,\n  arrayBuffer2: ArrayBuffer,\n  byteLength?: number\n): boolean {\n  byteLength = byteLength || arrayBuffer1.byteLength;\n  if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {\n    return false;\n  }\n  const array1 = new Uint8Array(arrayBuffer1);\n  const array2 = new Uint8Array(arrayBuffer2);\n  for (let i = 0; i < array1.length; ++i) {\n    if (array1[i] !== array2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Concatenate a sequence of ArrayBuffers\n * @return A concatenated ArrayBuffer\n */\nexport function concatenateArrayBuffers(...sources: (ArrayBuffer | Uint8Array)[]): ArrayBuffer {\n  // Make sure all inputs are wrapped in typed arrays\n  const sourceArrays = sources.map((source2) =>\n    source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2\n  );\n\n  // Get length of all inputs\n  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);\n\n  // Allocate array with space for all inputs\n  const result = new Uint8Array(byteLength);\n\n  // Copy the subarrays\n  let offset = 0;\n  for (const sourceArray of sourceArrays) {\n    result.set(sourceArray, offset);\n    offset += sourceArray.byteLength;\n  }\n\n  // We work with ArrayBuffers, discard the typed array wrapper\n  return result.buffer;\n}\n\n/**\n * Concatenate arbitrary count of typed arrays\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays\n * @param {...*} arrays - list of arrays. All arrays should be the same type\n * @return A concatenated TypedArray\n */\nexport function concatenateTypedArrays<T>(...typedArrays: T[]): T {\n  // @ts-ignore\n  const arrays = typedArrays as TypedArray[];\n  // @ts-ignore\n  const TypedArrayConstructor = (arrays && arrays.length > 1 && arrays[0].constructor) || null;\n  if (!TypedArrayConstructor) {\n    throw new Error(\n      '\"concatenateTypedArrays\" - incorrect quantity of arguments or arguments have incompatible data types'\n    );\n  }\n\n  const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);\n  // @ts-ignore typescript does not like dynamic constructors\n  const result = new TypedArrayConstructor(sumLength);\n  let offset = 0;\n  for (const array of arrays) {\n    result.set(array, offset);\n    offset += array.length;\n  }\n  return result;\n}\n\n/**\n * Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0\n * @param arrayBuffer\n * @param byteOffset\n * @param byteLength\n */\nexport function sliceArrayBuffer(\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number,\n  byteLength?: number\n): ArrayBuffer {\n  const subArray =\n    byteLength !== undefined\n      ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength)\n      : new Uint8Array(arrayBuffer).subarray(byteOffset);\n  const arrayCopy = new Uint8Array(subArray);\n  return arrayCopy.buffer;\n}\n"],"file":"array-buffer-utils.js"}

package/dist/es5/lib/binary-utils/buffer-utils.js

@@ -13,7 +13,7 @@ exports.bufferToArrayBuffer = bufferToArrayBuffer;
 
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
-var node = _interopRequireWildcard(require("../node/buffer-utils.node"));
+var node = _interopRequireWildcard(require("../node/buffer"));
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 

package/dist/es5/lib/binary-utils/buffer-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/binary-utils/buffer-utils.ts"],"names":["isBuffer","value","toBuffer","data","node","bufferToArrayBuffer","toArrayBuffer"],"mappings":";;;;;;;;;;;;;;;AAAA;;;;;;AAKO,SAASA,QAAT,CAAkBC,KAAlB,EAAuC;AAC5C,SAAOA,KAAK,IAAI,sBAAOA,KAAP,MAAiB,QAA1B,IAAsCA,KAAK,CAACD,QAAnD;AACD;;AAMM,SAASE,QAAT,CAAkBC,IAAlB,EAAqC;AAC1C,SAAOC,IAAI,CAACF,QAAL,GAAgBE,IAAI,CAACF,QAAL,CAAcC,IAAd,CAAhB,GAAsCA,IAA7C;AACD;;AAMM,SAASE,mBAAT,CAA6BF,IAA7B,EAAqD;AAC1D,MAAIC,IAAI,CAACE,aAAT,EAAwB;AAEtB,WAAOF,IAAI,CAACE,aAAL,CAAmBH,IAAnB,CAAP;AACD;;AACD,SAAOA,IAAP;AACD","sourcesContent":["import * as node from '../node/buffer-utils.node';\n\n/**\n * Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n */\nexport function isBuffer(value: any): boolean {\n  return value && typeof value === 'object' && value.isBuffer;\n}\n\n/**\n * Converts to Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function toBuffer(data: any): Buffer {\n  return node.toBuffer ? node.toBuffer(data) : data;\n}\n\n/**\n * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function bufferToArrayBuffer(data: any): ArrayBuffer {\n  if (node.toArrayBuffer) {\n    // TODO - per docs we should just be able to call buffer.buffer, but there are issues\n    return node.toArrayBuffer(data);\n  }\n  return data;\n}\n"],"file":"buffer-utils.js"}
+{"version":3,"sources":["../../../../src/lib/binary-utils/buffer-utils.ts"],"names":["isBuffer","value","toBuffer","data","node","bufferToArrayBuffer","toArrayBuffer"],"mappings":";;;;;;;;;;;;;;;AAAA;;;;;;AAKO,SAASA,QAAT,CAAkBC,KAAlB,EAAuC;AAC5C,SAAOA,KAAK,IAAI,sBAAOA,KAAP,MAAiB,QAA1B,IAAsCA,KAAK,CAACD,QAAnD;AACD;;AAMM,SAASE,QAAT,CAAkBC,IAAlB,EAAqC;AAC1C,SAAOC,IAAI,CAACF,QAAL,GAAgBE,IAAI,CAACF,QAAL,CAAcC,IAAd,CAAhB,GAAsCA,IAA7C;AACD;;AAMM,SAASE,mBAAT,CAA6BF,IAA7B,EAAqD;AAC1D,MAAIC,IAAI,CAACE,aAAT,EAAwB;AAEtB,WAAOF,IAAI,CAACE,aAAL,CAAmBH,IAAnB,CAAP;AACD;;AACD,SAAOA,IAAP;AACD","sourcesContent":["import * as node from '../node/buffer';\n\n/**\n * Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n */\nexport function isBuffer(value: any): boolean {\n  return value && typeof value === 'object' && value.isBuffer;\n}\n\n/**\n * Converts to Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function toBuffer(data: any): Buffer {\n  return node.toBuffer ? node.toBuffer(data) : data;\n}\n\n/**\n * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function bufferToArrayBuffer(data: any): ArrayBuffer {\n  if (node.toArrayBuffer) {\n    // TODO - per docs we should just be able to call buffer.buffer, but there are issues\n    return node.toArrayBuffer(data);\n  }\n  return data;\n}\n"],"file":"buffer-utils.js"}

package/dist/es5/lib/filesystems/node-filesystem.js

@@ -0,0 +1,267 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var fs = _interopRequireWildcard(require("../node/fs"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var NodeFileSystem = function () {
+  function NodeFileSystem(options) {
+    (0, _classCallCheck2.default)(this, NodeFileSystem);
+    this.fetch = options._fetch;
+  }
+
+  (0, _createClass2.default)(NodeFileSystem, [{
+    key: "readdir",
+    value: function () {
+      var _readdir = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
+        var dirname,
+            options,
+            _args = arguments;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                dirname = _args.length > 0 && _args[0] !== undefined ? _args[0] : '.';
+                options = _args.length > 1 ? _args[1] : undefined;
+                _context.next = 4;
+                return fs.readdir(dirname, options);
+
+              case 4:
+                return _context.abrupt("return", _context.sent);
+
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function readdir() {
+        return _readdir.apply(this, arguments);
+      }
+
+      return readdir;
+    }()
+  }, {
+    key: "stat",
+    value: function () {
+      var _stat = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(path, options) {
+        var info;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return fs.stat(path, options);
+
+              case 2:
+                info = _context2.sent;
+                return _context2.abrupt("return", {
+                  size: Number(info.size),
+                  isDirectory: function isDirectory() {
+                    return false;
+                  },
+                  info: info
+                });
+
+              case 4:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function stat(_x, _x2) {
+        return _stat.apply(this, arguments);
+      }
+
+      return stat;
+    }()
+  }, {
+    key: "fetch",
+    value: function () {
+      var _fetch = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(path, options) {
+        var fallbackFetch;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                fallbackFetch = options.fetch || this.fetch;
+                return _context3.abrupt("return", fallbackFetch(path, options));
+
+              case 2:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function fetch(_x3, _x4) {
+        return _fetch.apply(this, arguments);
+      }
+
+      return fetch;
+    }()
+  }, {
+    key: "open",
+    value: function () {
+      var _open = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee4(path, flags, mode) {
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _context4.next = 2;
+                return fs.open(path, flags);
+
+              case 2:
+                return _context4.abrupt("return", _context4.sent);
+
+              case 3:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4);
+      }));
+
+      function open(_x5, _x6, _x7) {
+        return _open.apply(this, arguments);
+      }
+
+      return open;
+    }()
+  }, {
+    key: "close",
+    value: function () {
+      var _close = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee5(fd) {
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _context5.next = 2;
+                return fs.close(fd);
+
+              case 2:
+                return _context5.abrupt("return", _context5.sent);
+
+              case 3:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5);
+      }));
+
+      function close(_x8) {
+        return _close.apply(this, arguments);
+      }
+
+      return close;
+    }()
+  }, {
+    key: "fstat",
+    value: function () {
+      var _fstat = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee6(fd) {
+        var info;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                _context6.next = 2;
+                return fs.fstat(fd);
+
+              case 2:
+                info = _context6.sent;
+                return _context6.abrupt("return", info);
+
+              case 4:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6);
+      }));
+
+      function fstat(_x9) {
+        return _fstat.apply(this, arguments);
+      }
+
+      return fstat;
+    }()
+  }, {
+    key: "read",
+    value: function () {
+      var _read = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee7(fd, _ref) {
+        var _ref$buffer, buffer, _ref$offset, offset, _ref$length, length, _ref$position, position, totalBytesRead, _yield$fs$read, bytesRead;
+
+        return _regenerator.default.wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                _ref$buffer = _ref.buffer, buffer = _ref$buffer === void 0 ? null : _ref$buffer, _ref$offset = _ref.offset, offset = _ref$offset === void 0 ? 0 : _ref$offset, _ref$length = _ref.length, length = _ref$length === void 0 ? buffer.byteLength : _ref$length, _ref$position = _ref.position, position = _ref$position === void 0 ? null : _ref$position;
+                totalBytesRead = 0;
+
+              case 2:
+                if (!(totalBytesRead < length)) {
+                  _context7.next = 10;
+                  break;
+                }
+
+                _context7.next = 5;
+                return fs.read(fd, buffer, offset + totalBytesRead, length - totalBytesRead, position + totalBytesRead);
+
+              case 5:
+                _yield$fs$read = _context7.sent;
+                bytesRead = _yield$fs$read.bytesRead;
+                totalBytesRead += bytesRead;
+                _context7.next = 2;
+                break;
+
+              case 10:
+                return _context7.abrupt("return", {
+                  bytesRead: totalBytesRead,
+                  buffer: buffer
+                });
+
+              case 11:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7);
+      }));
+
+      function read(_x10, _x11) {
+        return _read.apply(this, arguments);
+      }
+
+      return read;
+    }()
+  }]);
+  return NodeFileSystem;
+}();
+
+exports.default = NodeFileSystem;
+//# sourceMappingURL=node-filesystem.js.map

package/dist/es5/lib/filesystems/node-filesystem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/filesystems/node-filesystem.ts"],"names":["NodeFileSystem","options","fetch","_fetch","dirname","fs","readdir","path","stat","info","size","Number","isDirectory","fallbackFetch","flags","mode","open","fd","close","fstat","buffer","offset","length","byteLength","position","totalBytesRead","read","bytesRead"],"mappings":"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","sourcesContent":["import * as fs from '../node/fs';\nimport {IFileSystem, IRandomAccessReadFileSystem} from '@loaders.gl/loader-utils';\n// import {fetchFile} from \"../fetch/fetch-file\"\n// import {selectLoader} from \"../api/select-loader\";\n\ntype Stat = {\n  size: number;\n  isDirectory: () => boolean;\n  info?: fs.Stats;\n};\n\ntype ReadOptions = {\n  buffer?: Buffer;\n  offset?: number;\n  length?: number;\n  position?: number;\n};\n\n/**\n * FileSystem pass-through for Node.js\n * Compatible with BrowserFileSystem.\n * @param options\n */\nexport default class NodeFileSystem implements IFileSystem, IRandomAccessReadFileSystem {\n  // implements IFileSystem\n  constructor(options: {[key: string]: any}) {\n    this.fetch = options._fetch;\n  }\n\n  async readdir(dirname = '.', options?: {}): Promise<any[]> {\n    return await fs.readdir(dirname, options);\n  }\n\n  async stat(path: string, options?: {}): Promise<Stat> {\n    const info = await fs.stat(path, options);\n    return {size: Number(info.size), isDirectory: () => false, info};\n  }\n\n  async fetch(path: string, options: {[key: string]: any}) {\n    // Falls back to handle https:/http:/data: etc fetches\n    // eslint-disable-next-line\n    const fallbackFetch = options.fetch || this.fetch;\n    return fallbackFetch(path, options);\n  }\n\n  // implements IRandomAccessFileSystem\n  async open(path: string, flags: string | number, mode?: any): Promise<number> {\n    return await fs.open(path, flags);\n  }\n\n  async close(fd: number): Promise<void> {\n    return await fs.close(fd);\n  }\n\n  async fstat(fd: number): Promise<Stat> {\n    const info = await fs.fstat(fd);\n    return info;\n  }\n\n  async read(\n    fd: number,\n    // @ts-ignore Possibly null\n    {buffer = null, offset = 0, length = buffer.byteLength, position = null}: ReadOptions\n  ): Promise<{bytesRead: number; buffer: Buffer}> {\n    let totalBytesRead = 0;\n    // Read in loop until we get required number of bytes\n    while (totalBytesRead < length) {\n      const {bytesRead} = await fs.read(\n        fd,\n        buffer,\n        offset + totalBytesRead,\n        length - totalBytesRead,\n        position + totalBytesRead\n      );\n      totalBytesRead += bytesRead;\n    }\n    return {bytesRead: totalBytesRead, buffer};\n  }\n}\n"],"file":"node-filesystem.js"}

package/dist/es5/lib/node/{buffer-utils.node.js → buffer.js}

@@ -35,4 +35,4 @@ function toBuffer(binaryData) {
 
   return (0, _assert.assert)(false);
 }
-//# sourceMappingURL=buffer-utils.node.js.map
+//# sourceMappingURL=buffer.js.map

package/dist/es5/lib/node/buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/node/buffer.ts"],"names":["toArrayBuffer","buffer","Buffer","isBuffer","typedArray","Uint8Array","toBuffer","binaryData","ArrayBuffer","isView","byteLength","view","i","length"],"mappings":";;;;;;;;AAGA;;AAKO,SAASA,aAAT,CAAuBC,MAAvB,EAA+B;AAEpC,MAAIC,MAAM,CAACC,QAAP,CAAgBF,MAAhB,CAAJ,EAA6B;AAC3B,QAAMG,UAAU,GAAG,IAAIC,UAAJ,CAAeJ,MAAf,CAAnB;AACA,WAAOG,UAAU,CAACH,MAAlB;AACD;;AACD,SAAOA,MAAP;AACD;;AAKM,SAASK,QAAT,CAAkBC,UAAlB,EAA8B;AACnC,MAAIC,WAAW,CAACC,MAAZ,CAAmBF,UAAnB,CAAJ,EAAoC;AAClCA,IAAAA,UAAU,GAAGA,UAAU,CAACN,MAAxB;AACD;;AAED,MAAI,OAAOC,MAAP,KAAkB,WAAlB,IAAiCK,UAAU,YAAYC,WAA3D,EAAwE;AACtE,QAAMP,MAAM,GAAG,IAAIC,MAAJ,CAAWK,UAAU,CAACG,UAAtB,CAAf;AACA,QAAMC,IAAI,GAAG,IAAIN,UAAJ,CAAeE,UAAf,CAAb;;AACA,SAAK,IAAIK,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGX,MAAM,CAACY,MAA3B,EAAmC,EAAED,CAArC,EAAwC;AACtCX,MAAAA,MAAM,CAACW,CAAD,CAAN,GAAYD,IAAI,CAACC,CAAD,CAAhB;AACD;;AACD,WAAOX,MAAP;AACD;;AAED,SAAO,oBAAO,KAAP,CAAP;AACD","sourcesContent":["// Isolates Buffer references to ensure they are only bundled under Node.js (avoids big webpack polyfill)\n// this file is not visible to webpack (it is excluded in the package.json \"browser\" field).\n\nimport {assert} from '../env-utils/assert';\n\n/**\n * Convert Buffer to ArrayBuffer\n */\nexport function toArrayBuffer(buffer) {\n  // TODO - per docs we should just be able to call buffer.buffer, but there are issues\n  if (Buffer.isBuffer(buffer)) {\n    const typedArray = new Uint8Array(buffer);\n    return typedArray.buffer;\n  }\n  return buffer;\n}\n\n/**\n * Convert (copy) ArrayBuffer to Buffer\n */\nexport function toBuffer(binaryData) {\n  if (ArrayBuffer.isView(binaryData)) {\n    binaryData = binaryData.buffer;\n  }\n\n  if (typeof Buffer !== 'undefined' && binaryData instanceof ArrayBuffer) {\n    const buffer = new Buffer(binaryData.byteLength);\n    const view = new Uint8Array(binaryData);\n    for (let i = 0; i < buffer.length; ++i) {\n      buffer[i] = view[i];\n    }\n    return buffer;\n  }\n\n  return assert(false);\n}\n"],"file":"buffer.js"}

package/dist/es5/lib/node/fs.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports._readToArrayBuffer = _readToArrayBuffer;
-exports.writeFileSync = exports.writeFile = exports.readFileSync = exports.readFile = exports.read = exports.close = exports.open = exports.isSupported = void 0;
+exports.isSupported = exports.fstat = exports.read = exports.close = exports.open = exports.writeFileSync = exports.writeFile = exports.readFileSync = exports.readFile = exports.stat = exports.readdir = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -14,32 +14,32 @@ var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/
 
 var _fs = _interopRequireDefault(require("fs"));
 
-var _bufferUtils = require("./buffer-utils.node");
+var _buffer = require("./buffer");
 
-var _util = require("util");
+var _util = require("./util");
 
-var error = function error(fsFunction) {
-  return function () {
-    throw new Error("".concat(fsFunction, " not available in browser"));
-  };
-};
-
-var isSupported = Boolean(_fs.default);
-exports.isSupported = isSupported;
-var open = _fs.default !== null && _fs.default !== void 0 && _fs.default.open ? (0, _util.promisify)(_fs.default.open) : error('fs.open');
-exports.open = open;
-var close = _fs.default !== null && _fs.default !== void 0 && _fs.default.close ? (0, _util.promisify)(_fs.default.close) : error('fs.close');
-exports.close = close;
-var read = _fs.default !== null && _fs.default !== void 0 && _fs.default.read ? (0, _util.promisify)(_fs.default.read) : error('fs.read');
-exports.read = read;
-var readFile = _fs.default !== null && _fs.default !== void 0 && _fs.default.readFile ? (0, _util.promisify)(_fs.default.readFile) : error('fs.readFile');
+var readdir = (0, _util.promisify)(_fs.default.readdir);
+exports.readdir = readdir;
+var stat = (0, _util.promisify)(_fs.default.stat);
+exports.stat = stat;
+var readFile = (0, _util.promisify)(_fs.default.readFile);
 exports.readFile = readFile;
-var readFileSync = _fs.default !== null && _fs.default !== void 0 && _fs.default.readFileSync ? _fs.default.readFileSync : error('fs.readFileSync');
+var readFileSync = _fs.default.readFileSync;
 exports.readFileSync = readFileSync;
-var writeFile = _fs.default !== null && _fs.default !== void 0 && _fs.default.writeFile ? (0, _util.promisify)(_fs.default.writeFile) : error('fs.writeFile');
+var writeFile = (0, _util.promisify)(_fs.default.writeFile);
 exports.writeFile = writeFile;
-var writeFileSync = _fs.default !== null && _fs.default !== void 0 && _fs.default.writeFileSync ? _fs.default.writeFileSync : error('fs.writeFileSync');
+var writeFileSync = _fs.default.writeFileSync;
 exports.writeFileSync = writeFileSync;
+var open = (0, _util.promisify)(_fs.default.open);
+exports.open = open;
+var close = (0, _util.promisify)(_fs.default.close);
+exports.close = close;
+var read = (0, _util.promisify)(_fs.default.read);
+exports.read = read;
+var fstat = (0, _util.promisify)(_fs.default.fstat);
+exports.fstat = fstat;
+var isSupported = Boolean(_fs.default);
+exports.isSupported = isSupported;
 
 function _readToArrayBuffer(_x, _x2, _x3) {
   return _readToArrayBuffer2.apply(this, arguments);
@@ -69,7 +69,7 @@ function _readToArrayBuffer2() {
             throw new Error('fs.read failed');
 
           case 7:
-            return _context.abrupt("return", (0, _bufferUtils.toArrayBuffer)(buffer));
+            return _context.abrupt("return", (0, _buffer.toArrayBuffer)(buffer));
 
           case 8:
           case "end":

package/dist/es5/lib/node/fs.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/node/fs.ts"],"names":["error","fsFunction","Error","isSupported","Boolean","fs","open","close","read","readFile","readFileSync","writeFile","writeFileSync","_readToArrayBuffer","fd","start","length","buffer","Buffer","alloc","bytesRead"],"mappings":";;;;;;;;;;;;;;AACA;;AACA;;AACA;;AAEA,IAAMA,KAAK,GAAG,SAARA,KAAQ,CAACC,UAAD;AAAA,SAAgB,YAAM;AAClC,UAAM,IAAIC,KAAJ,WAAaD,UAAb,+BAAN;AACD,GAFa;AAAA,CAAd;;AAIO,IAAME,WAAW,GAAGC,OAAO,CAACC,WAAD,CAA3B;;AAEA,IAAMC,IAAI,GAAGD,8DAAIC,IAAJ,GAAW,qBAAUD,YAAGC,IAAb,CAAX,GAAgCN,KAAK,CAAC,SAAD,CAAlD;;AACA,IAAMO,KAAK,GAAGF,8DAAIE,KAAJ,GAAY,qBAAUF,YAAGE,KAAb,CAAZ,GAAkCP,KAAK,CAAC,UAAD,CAArD;;AACA,IAAMQ,IAAI,GAAGH,8DAAIG,IAAJ,GAAW,qBAAUH,YAAGG,IAAb,CAAX,GAAgCR,KAAK,CAAC,SAAD,CAAlD;;AAEA,IAAMS,QAAQ,GAAGJ,8DAAII,QAAJ,GAAe,qBAAUJ,YAAGI,QAAb,CAAf,GAAwCT,KAAK,CAAC,aAAD,CAA9D;;AACA,IAAMU,YAAY,GAAGL,8DAAIK,YAAJ,GAAmBL,YAAGK,YAAtB,GAAqCV,KAAK,CAAC,iBAAD,CAA/D;;AACA,IAAMW,SAAS,GAAGN,8DAAIM,SAAJ,GAAgB,qBAAUN,YAAGM,SAAb,CAAhB,GAA0CX,KAAK,CAAC,cAAD,CAAjE;;AACA,IAAMY,aAAa,GAAGP,8DAAIO,aAAJ,GAAoBP,YAAGO,aAAvB,GAAuCZ,KAAK,CAAC,kBAAD,CAAlE;;;SAEea,kB;;;;;kFAAf,iBAAkCC,EAAlC,EAA8CC,KAA9C,EAA6DC,MAA7D;AAAA;;AAAA;AAAA;AAAA;AAAA;AACCC,YAAAA,MADD,GACUC,MAAM,CAACC,KAAP,CAAaH,MAAb,CADV;AAAA;AAAA,mBAEqBR,IAAI,CAACM,EAAD,EAAKG,MAAL,EAAa,CAAb,EAAgBD,MAAhB,EAAwBD,KAAxB,CAFzB;;AAAA;AAAA;AAEEK,YAAAA,SAFF,eAEEA,SAFF;;AAAA,kBAGDA,SAAS,KAAKJ,MAHb;AAAA;AAAA;AAAA;;AAAA,kBAIG,IAAId,KAAJ,CAAU,gBAAV,CAJH;;AAAA;AAAA,6CAME,gCAAce,MAAd,CANF;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","sourcesContent":["// fs wrapper (promisified fs + avoids bundling fs in browsers)\nimport fs from 'fs';\nimport {toArrayBuffer} from './buffer-utils.node';\nimport {promisify} from 'util';\n\nconst error = (fsFunction) => () => {\n  throw new Error(`${fsFunction} not available in browser`);\n};\n\nexport const isSupported = Boolean(fs);\n\nexport const open = fs?.open ? promisify(fs.open) : error('fs.open');\nexport const close = fs?.close ? promisify(fs.close) : error('fs.close');\nexport const read = fs?.read ? promisify(fs.read) : error('fs.read');\n\nexport const readFile = fs?.readFile ? promisify(fs.readFile) : error('fs.readFile');\nexport const readFileSync = fs?.readFileSync ? fs.readFileSync : error('fs.readFileSync');\nexport const writeFile = fs?.writeFile ? promisify(fs.writeFile) : error('fs.writeFile');\nexport const writeFileSync = fs?.writeFileSync ? fs.writeFileSync : error('fs.writeFileSync');\n\nexport async function _readToArrayBuffer(fd: number, start: number, length: number) {\n  const buffer = Buffer.alloc(length);\n  const {bytesRead} = await read(fd, buffer, 0, length, start);\n  if (bytesRead !== length) {\n    throw new Error('fs.read failed');\n  }\n  return toArrayBuffer(buffer);\n}\n"],"file":"fs.js"}
+{"version":3,"sources":["../../../../src/lib/node/fs.ts"],"names":["readdir","fs","stat","readFile","readFileSync","writeFile","writeFileSync","open","close","read","fstat","isSupported","Boolean","_readToArrayBuffer","fd","start","length","buffer","Buffer","alloc","bytesRead","Error"],"mappings":";;;;;;;;;;;;;;AACA;;AACA;;AACA;;AAOO,IAAMA,OAAO,GAAG,qBAAUC,YAAGD,OAAb,CAAhB;;AAEA,IAAME,IAAI,GAAG,qBAAUD,YAAGC,IAAb,CAAb;;AAGA,IAAMC,QAAQ,GAAG,qBAAUF,YAAGE,QAAb,CAAjB;;AAEA,IAAMC,YAAY,GAAGH,YAAGG,YAAxB;;AAEA,IAAMC,SAAS,GAAG,qBAAUJ,YAAGI,SAAb,CAAlB;;AAEA,IAAMC,aAAa,GAAGL,YAAGK,aAAzB;;AAKA,IAAMC,IAAI,GAAG,qBAAUN,YAAGM,IAAb,CAAb;;AAEA,IAAMC,KAAK,GAAG,qBAAUP,YAAGO,KAAb,CAAd;;AAEA,IAAMC,IAAI,GAAG,qBAAUR,YAAGQ,IAAb,CAAb;;AAEA,IAAMC,KAAK,GAAG,qBAAUT,YAAGS,KAAb,CAAd;;AAEA,IAAMC,WAAW,GAAGC,OAAO,CAACX,WAAD,CAA3B;;;SAEeY,kB;;;;;kFAAf,iBAAkCC,EAAlC,EAA8CC,KAA9C,EAA6DC,MAA7D;AAAA;;AAAA;AAAA;AAAA;AAAA;AACCC,YAAAA,MADD,GACUC,MAAM,CAACC,KAAP,CAAaH,MAAb,CADV;AAAA;AAAA,mBAEqBP,IAAI,CAACK,EAAD,EAAKG,MAAL,EAAa,CAAb,EAAgBD,MAAhB,EAAwBD,KAAxB,CAFzB;;AAAA;AAAA;AAEEK,YAAAA,SAFF,eAEEA,SAFF;;AAAA,kBAGDA,SAAS,KAAKJ,MAHb;AAAA;AAAA;AAAA;;AAAA,kBAIG,IAAIK,KAAJ,CAAU,gBAAV,CAJH;;AAAA;AAAA,6CAME,2BAAcJ,MAAd,CANF;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","sourcesContent":["// fs wrapper (promisified fs + avoids bundling fs in browsers)\nimport fs from 'fs';\nimport {toArrayBuffer} from './buffer';\nimport {promisify} from './util';\n\nexport type {Stats} from 'fs';\n\n// paths\n\n/** Wrapper for Node.js fs method */\nexport const readdir = promisify(fs.readdir);\n/** Wrapper for Node.js fs method */\nexport const stat = promisify(fs.stat);\n\n/** Wrapper for Node.js fs method */\nexport const readFile = promisify(fs.readFile);\n/** Wrapper for Node.js fs method */\nexport const readFileSync = fs.readFileSync;\n/** Wrapper for Node.js fs method */\nexport const writeFile = promisify(fs.writeFile);\n/** Wrapper for Node.js fs method */\nexport const writeFileSync = fs.writeFileSync;\n\n// file descriptors\n\n/** Wrapper for Node.js fs method */\nexport const open = promisify(fs.open);\n/** Wrapper for Node.js fs method */\nexport const close = promisify(fs.close);\n/** Wrapper for Node.js fs method */\nexport const read = promisify(fs.read);\n/** Wrapper for Node.js fs method */\nexport const fstat = promisify(fs.fstat);\n\nexport const isSupported = Boolean(fs);\n\nexport async function _readToArrayBuffer(fd: number, start: number, length: number) {\n  const buffer = Buffer.alloc(length);\n  const {bytesRead} = await read(fd, buffer, 0, length, start);\n  if (bytesRead !== length) {\n    throw new Error('fs.read failed');\n  }\n  return toArrayBuffer(buffer);\n}\n"],"file":"fs.js"}

package/dist/es5/lib/node/util.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.promisify = void 0;
+
+var util = _interopRequireWildcard(require("util"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var promisify = util.promisify;
+exports.promisify = promisify;
+//# sourceMappingURL=util.js.map

package/dist/es5/lib/node/util.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/node/util.ts"],"names":["promisify","util"],"mappings":";;;;;;;;;AAAA;;;;;;AAGO,IAAMA,SAAS,GAAGC,IAAI,CAACD,SAAvB","sourcesContent":["import * as util from 'util';\n\n/** Wrapper for Node.js promisify */\nexport const promisify = util.promisify;\n"],"file":"util.js"}

package/dist/esm/index.js

@@ -11,12 +11,16 @@ export { getFirstCharacters, getMagicString } from './lib/binary-utils/get-first
 export { makeTextEncoderIterator, makeTextDecoderIterator, makeLineIterator, makeNumberedLineIterator } from './lib/iterators/text-iterators';
 export { forEach, concatenateArrayBuffersAsync } from './lib/iterators/async-iteration';
 export { default as RequestScheduler } from './lib/request-utils/request-scheduler';
-import * as path from './lib/path-utils/path';
-export { path };
 export { setPathPrefix, getPathPrefix, resolvePath } from './lib/path-utils/file-aliases';
 export { addAliases as _addAliases } from './lib/path-utils/file-aliases';
+export { JSONLoader } from './json-loader';
+import * as path from './lib/path-utils/path';
+export { path };
+export { isBuffer, toBuffer, bufferToArrayBuffer } from './lib/binary-utils/buffer-utils';
+import * as util from './lib/node/util';
+export { util };
+export { promisify } from './lib/node/util';
 import * as fs from './lib/node/fs';
 export { fs };
-export { isBuffer, toBuffer, bufferToArrayBuffer } from './lib/binary-utils/buffer-utils';
-export { JSONLoader } from './json-loader';
+export { default as _NodeFileSystem } from './lib/filesystems/node-filesystem';
 //# sourceMappingURL=index.js.map