@loaders.gl/loader-utils 3.0.9 → 3.0.13

package/dist/es5/index.js

@@ -2,264 +2,274 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _typeof = require("@babel/runtime/helpers/typeof");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 Object.defineProperty(exports, "assert", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _assert.assert;
   }
 });
 Object.defineProperty(exports, "isBrowser", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.isBrowser;
   }
 });
 Object.defineProperty(exports, "isWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.isWorker;
   }
 });
 Object.defineProperty(exports, "nodeVersion", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.nodeVersion;
   }
 });
 Object.defineProperty(exports, "self", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.self;
   }
 });
 Object.defineProperty(exports, "window", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.window;
   }
 });
 Object.defineProperty(exports, "global", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.global;
   }
 });
 Object.defineProperty(exports, "document", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.document;
   }
 });
 Object.defineProperty(exports, "createLoaderWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _createLoaderWorker.createLoaderWorker;
   }
 });
 Object.defineProperty(exports, "parseWithWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _parseWithWorker.parseWithWorker;
   }
 });
 Object.defineProperty(exports, "canParseWithWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _parseWithWorker.canParseWithWorker;
   }
 });
 Object.defineProperty(exports, "parseJSON", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _parseJson.parseJSON;
   }
 });
 Object.defineProperty(exports, "toArrayBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.toArrayBuffer;
   }
 });
 Object.defineProperty(exports, "sliceArrayBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.sliceArrayBuffer;
   }
 });
 Object.defineProperty(exports, "concatenateArrayBuffers", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.concatenateArrayBuffers;
   }
 });
 Object.defineProperty(exports, "concatenateTypedArrays", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.concatenateTypedArrays;
   }
 });
 Object.defineProperty(exports, "compareArrayBuffers", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.compareArrayBuffers;
   }
 });
 Object.defineProperty(exports, "padToNBytes", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryCopyUtils.padToNBytes;
   }
 });
 Object.defineProperty(exports, "copyToArray", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryCopyUtils.copyToArray;
   }
 });
 Object.defineProperty(exports, "copyArrayBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryCopyUtils.copyArrayBuffer;
   }
 });
 Object.defineProperty(exports, "copyPaddedArrayBufferToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _binaryCopyUtils.copyPaddedArrayBufferToDataView;
   }
 });
 Object.defineProperty(exports, "copyPaddedStringToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _binaryCopyUtils.copyPaddedStringToDataView;
   }
 });
 Object.defineProperty(exports, "padStringToByteAlignment", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _encodeUtils.padStringToByteAlignment;
   }
 });
 Object.defineProperty(exports, "copyStringToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _encodeUtils.copyStringToDataView;
   }
 });
 Object.defineProperty(exports, "copyBinaryToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _encodeUtils.copyBinaryToDataView;
   }
 });
 Object.defineProperty(exports, "getFirstCharacters", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _getFirstCharacters.getFirstCharacters;
   }
 });
 Object.defineProperty(exports, "getMagicString", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _getFirstCharacters.getMagicString;
   }
 });
 Object.defineProperty(exports, "makeTextEncoderIterator", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _textIterators.makeTextEncoderIterator;
   }
 });
 Object.defineProperty(exports, "makeTextDecoderIterator", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _textIterators.makeTextDecoderIterator;
   }
 });
 Object.defineProperty(exports, "makeLineIterator", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _textIterators.makeLineIterator;
   }
 });
 Object.defineProperty(exports, "makeNumberedLineIterator", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _textIterators.makeNumberedLineIterator;
   }
 });
 Object.defineProperty(exports, "forEach", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _asyncIteration.forEach;
   }
 });
 Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _asyncIteration.concatenateArrayBuffersAsync;
   }
 });
 Object.defineProperty(exports, "RequestScheduler", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _requestScheduler.default;
   }
 });
 Object.defineProperty(exports, "setPathPrefix", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.setPathPrefix;
   }
 });
 Object.defineProperty(exports, "getPathPrefix", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.getPathPrefix;
   }
 });
 Object.defineProperty(exports, "resolvePath", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.resolvePath;
   }
 });
 Object.defineProperty(exports, "_addAliases", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.addAliases;
   }
 });
+Object.defineProperty(exports, "JSONLoader", {
+  enumerable: true,
+  get: function () {
+    return _jsonLoader.JSONLoader;
+  }
+});
 Object.defineProperty(exports, "isBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _bufferUtils.isBuffer;
   }
 });
 Object.defineProperty(exports, "toBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _bufferUtils.toBuffer;
   }
 });
 Object.defineProperty(exports, "bufferToArrayBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _bufferUtils.bufferToArrayBuffer;
   }
 });
-Object.defineProperty(exports, "JSONLoader", {
+Object.defineProperty(exports, "promisify", {
   enumerable: true,
-  get: function get() {
-    return _jsonLoader.JSONLoader;
+  get: function () {
+    return util.promisify;
+  }
+});
+Object.defineProperty(exports, "_NodeFileSystem", {
+  enumerable: true,
+  get: function () {
+    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,21 +297,27 @@ 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); }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (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; }
+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; }
 //# sourceMappingURL=index.js.map

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

@@ -1,18 +1,11 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports._typecheckJSONLoader = exports.JSONLoader = void 0;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var VERSION = typeof "3.0.9" !== 'undefined' ? "3.0.9" : 'latest';
-var JSONLoader = {
+const VERSION = typeof "3.0.13" !== 'undefined' ? "3.0.13" : 'latest';
+const JSONLoader = {
   name: 'JSON',
   id: 'json',
   module: 'json',
@@ -21,29 +14,8 @@ var JSONLoader = {
   mimeTypes: ['application/json'],
   category: 'json',
   text: true,
-  parseTextSync: parseTextSync,
-  parse: function () {
-    var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer) {
-      return _regenerator.default.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              return _context.abrupt("return", parseTextSync(new TextDecoder().decode(arrayBuffer)));
-
-            case 1:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee);
-    }));
-
-    function parse(_x) {
-      return _parse.apply(this, arguments);
-    }
-
-    return parse;
-  }(),
+  parseTextSync,
+  parse: async arrayBuffer => parseTextSync(new TextDecoder().decode(arrayBuffer)),
   options: {}
 };
 exports.JSONLoader = JSONLoader;
@@ -52,6 +24,6 @@ function parseTextSync(text) {
   return JSON.parse(text);
 }
 
-var _typecheckJSONLoader = JSONLoader;
+const _typecheckJSONLoader = JSONLoader;
 exports._typecheckJSONLoader = _typecheckJSONLoader;
 //# sourceMappingURL=json-loader.js.map

package/dist/es5/json-loader.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/json-loader.ts"],"names":["VERSION","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parseTextSync","parse","arrayBuffer","TextDecoder","decode","options","JSON","_typecheckJSONLoader"],"mappings":";;;;;;;;;;;;;AAIA,IAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAMO,IAAMC,UAAU,GAAG;AACxBC,EAAAA,IAAI,EAAE,MADkB;AAExBC,EAAAA,EAAE,EAAE,MAFoB;AAGxBC,EAAAA,MAAM,EAAE,MAHgB;AAIxBC,EAAAA,OAAO,EAAEL,OAJe;AAKxBM,EAAAA,UAAU,EAAE,CAAC,MAAD,EAAS,SAAT,CALY;AAMxBC,EAAAA,SAAS,EAAE,CAAC,kBAAD,CANa;AAOxBC,EAAAA,QAAQ,EAAE,MAPc;AAQxBC,EAAAA,IAAI,EAAE,IARkB;AASxBC,EAAAA,aAAa,EAAbA,aATwB;AAUxBC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAuBF,aAAa,CAAC,IAAIG,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,CAApC;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAVmB;AAWxBG,EAAAA,OAAO,EAAE;AAXe,CAAnB;;;AAeP,SAASL,aAAT,CAAuBD,IAAvB,EAA6B;AAC3B,SAAOO,IAAI,CAACL,KAAL,CAAWF,IAAX,CAAP;AACD;;AAEM,IAAMQ,oBAAsC,GAAGhB,UAA/C","sourcesContent":["import type {LoaderWithParser} from './types';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * A JSON Micro loader (minimal bundle size)\n * Alternative to `@loaders.gl/json`\n */\nexport const JSONLoader = {\n  name: 'JSON',\n  id: 'json',\n  module: 'json',\n  version: VERSION,\n  extensions: ['json', 'geojson'],\n  mimeTypes: ['application/json'],\n  category: 'json',\n  text: true,\n  parseTextSync,\n  parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),\n  options: {}\n};\n\n// TODO - deprecated\nfunction parseTextSync(text) {\n  return JSON.parse(text);\n}\n\nexport const _typecheckJSONLoader: LoaderWithParser = JSONLoader;\n"],"file":"json-loader.js"}
+{"version":3,"sources":["../../src/json-loader.ts"],"names":["VERSION","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parseTextSync","parse","arrayBuffer","TextDecoder","decode","options","JSON","_typecheckJSONLoader"],"mappings":";;;;;;AAIA,MAAMA,OAAO,GAAG,oBAAuB,WAAvB,cAAmD,QAAnE;AAMO,MAAMC,UAAU,GAAG;AACxBC,EAAAA,IAAI,EAAE,MADkB;AAExBC,EAAAA,EAAE,EAAE,MAFoB;AAGxBC,EAAAA,MAAM,EAAE,MAHgB;AAIxBC,EAAAA,OAAO,EAAEL,OAJe;AAKxBM,EAAAA,UAAU,EAAE,CAAC,MAAD,EAAS,SAAT,CALY;AAMxBC,EAAAA,SAAS,EAAE,CAAC,kBAAD,CANa;AAOxBC,EAAAA,QAAQ,EAAE,MAPc;AAQxBC,EAAAA,IAAI,EAAE,IARkB;AASxBC,EAAAA,aATwB;AAUxBC,EAAAA,KAAK,EAAE,MAAOC,WAAP,IAAuBF,aAAa,CAAC,IAAIG,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,CAVnB;AAWxBG,EAAAA,OAAO,EAAE;AAXe,CAAnB;;;AAeP,SAASL,aAAT,CAAuBD,IAAvB,EAA6B;AAC3B,SAAOO,IAAI,CAACL,KAAL,CAAWF,IAAX,CAAP;AACD;;AAEM,MAAMQ,oBAAsC,GAAGhB,UAA/C","sourcesContent":["import type {LoaderWithParser} from './types';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * A JSON Micro loader (minimal bundle size)\n * Alternative to `@loaders.gl/json`\n */\nexport const JSONLoader = {\n  name: 'JSON',\n  id: 'json',\n  module: 'json',\n  version: VERSION,\n  extensions: ['json', 'geojson'],\n  mimeTypes: ['application/json'],\n  category: 'json',\n  text: true,\n  parseTextSync,\n  parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),\n  options: {}\n};\n\n// TODO - deprecated\nfunction parseTextSync(text) {\n  return JSON.parse(text);\n}\n\nexport const _typecheckJSONLoader: LoaderWithParser = JSONLoader;\n"],"file":"json-loader.js"}

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

@@ -1,9 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-var _typeof3 = require("@babel/runtime/helpers/typeof");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -13,23 +9,15 @@ exports.concatenateArrayBuffers = concatenateArrayBuffers;
 exports.concatenateTypedArrays = concatenateTypedArrays;
 exports.sliceArrayBuffer = sliceArrayBuffer;
 
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
-var node = _interopRequireWildcard(require("../node/buffer-utils.node"));
-
-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 || _typeof3(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; }
-
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+var node = _interopRequireWildcard(require("./buffer-utils"));
 
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-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 _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; }
 
 function toArrayBuffer(data) {
-  if (node.toArrayBuffer) {
-    data = node.toArrayBuffer(data);
+  if (node.isBuffer(data)) {
+    data = node.bufferToArrayBuffer(data);
   }
 
   if (data instanceof ArrayBuffer) {
@@ -37,16 +25,20 @@ 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') {
-    var text = data;
-    var uint8Array = new TextEncoder().encode(text);
+    const text = data;
+    const uint8Array = new TextEncoder().encode(text);
     return uint8Array.buffer;
   }
 
-  if (data && (0, _typeof2.default)(data) === 'object' && data._toArrayBuffer) {
+  if (data && typeof data === 'object' && data._toArrayBuffer) {
     return data._toArrayBuffer();
   }
 
@@ -60,10 +52,10 @@ function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
     return false;
   }
 
-  var array1 = new Uint8Array(arrayBuffer1);
-  var array2 = new Uint8Array(arrayBuffer2);
+  const array1 = new Uint8Array(arrayBuffer1);
+  const array2 = new Uint8Array(arrayBuffer2);
 
-  for (var i = 0; i < array1.length; ++i) {
+  for (let i = 0; i < array1.length; ++i) {
     if (array1[i] !== array2[i]) {
       return false;
     }
@@ -72,58 +64,33 @@ function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
   return true;
 }
 
-function concatenateArrayBuffers() {
-  for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
-    sources[_key] = arguments[_key];
-  }
+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;
 
-  var sourceArrays = sources.map(function (source2) {
-    return source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2;
-  });
-  var byteLength = sourceArrays.reduce(function (length, typedArray) {
-    return length + typedArray.byteLength;
-  }, 0);
-  var result = new Uint8Array(byteLength);
-  var offset = 0;
-
-  var _iterator = _createForOfIteratorHelper(sourceArrays),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var sourceArray = _step.value;
-      result.set(sourceArray, offset);
-      offset += sourceArray.byteLength;
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  for (const sourceArray of sourceArrays) {
+    result.set(sourceArray, offset);
+    offset += sourceArray.byteLength;
   }
 
   return result.buffer;
 }
 
-function concatenateTypedArrays() {
-  for (var _len2 = arguments.length, typedArrays = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-    typedArrays[_key2] = arguments[_key2];
-  }
-
-  var arrays = typedArrays;
-  var TypedArrayConstructor = arrays && arrays.length > 1 && arrays[0].constructor || null;
+function concatenateTypedArrays(...typedArrays) {
+  const arrays = typedArrays;
+  const TypedArrayConstructor = arrays && arrays.length > 1 && arrays[0].constructor || null;
 
   if (!TypedArrayConstructor) {
     throw new Error('"concatenateTypedArrays" - incorrect quantity of arguments or arguments have incompatible data types');
   }
 
-  var sumLength = arrays.reduce(function (acc, value) {
-    return acc + value.length;
-  }, 0);
-  var result = new TypedArrayConstructor(sumLength);
-  var offset = 0;
+  const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);
+  const result = new TypedArrayConstructor(sumLength);
+  let offset = 0;
 
-  for (var _i = 0, _arrays = arrays; _i < _arrays.length; _i++) {
-    var array = _arrays[_i];
+  for (const array of arrays) {
     result.set(array, offset);
     offset += array.length;
   }
@@ -132,8 +99,8 @@ function concatenateTypedArrays() {
 }
 
 function sliceArrayBuffer(arrayBuffer, byteOffset, byteLength) {
-  var subArray = byteLength !== undefined ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength) : new Uint8Array(arrayBuffer).subarray(byteOffset);
-  var arrayCopy = new Uint8Array(subArray);
+  const subArray = byteLength !== undefined ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength) : new Uint8Array(arrayBuffer).subarray(byteOffset);
+  const arrayCopy = new Uint8Array(subArray);
   return arrayCopy.buffer;
 }
 //# sourceMappingURL=array-buffer-utils.js.map