@loaders.gl/loader-utils 3.3.0-alpha.1 → 3.3.0-alpha.11

package/dist/es5/index.js

@@ -1,184 +1,189 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 var _typeof = require("@babel/runtime/helpers/typeof");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "assert", {
+Object.defineProperty(exports, "JSONLoader", {
   enumerable: true,
   get: function get() {
-    return _assert.assert;
+    return _jsonLoader.JSONLoader;
   }
 });
-Object.defineProperty(exports, "isBrowser", {
+Object.defineProperty(exports, "RequestScheduler", {
   enumerable: true,
   get: function get() {
-    return _globals.isBrowser;
+    return _requestScheduler.default;
   }
 });
-Object.defineProperty(exports, "isWorker", {
+Object.defineProperty(exports, "_NodeFileSystem", {
   enumerable: true,
   get: function get() {
-    return _globals.isWorker;
+    return _nodeFilesystem.default;
   }
 });
-Object.defineProperty(exports, "nodeVersion", {
+Object.defineProperty(exports, "_addAliases", {
   enumerable: true,
   get: function get() {
-    return _globals.nodeVersion;
+    return _fileAliases.addAliases;
   }
 });
-Object.defineProperty(exports, "self", {
+Object.defineProperty(exports, "assert", {
   enumerable: true,
   get: function get() {
-    return _globals.self;
+    return _assert.assert;
   }
 });
-Object.defineProperty(exports, "window", {
+Object.defineProperty(exports, "bufferToArrayBuffer", {
   enumerable: true,
   get: function get() {
-    return _globals.window;
+    return _bufferUtils.bufferToArrayBuffer;
   }
 });
-Object.defineProperty(exports, "global", {
+Object.defineProperty(exports, "canEncodeWithWorker", {
   enumerable: true,
   get: function get() {
-    return _globals.global;
+    return _encodeWithWorker.canEncodeWithWorker;
   }
 });
-Object.defineProperty(exports, "document", {
+Object.defineProperty(exports, "canParseWithWorker", {
   enumerable: true,
   get: function get() {
-    return _globals.document;
+    return _parseWithWorker.canParseWithWorker;
   }
 });
-Object.defineProperty(exports, "createLoaderWorker", {
+Object.defineProperty(exports, "compareArrayBuffers", {
   enumerable: true,
   get: function get() {
-    return _createLoaderWorker.createLoaderWorker;
+    return _arrayBufferUtils.compareArrayBuffers;
   }
 });
-Object.defineProperty(exports, "parseWithWorker", {
+Object.defineProperty(exports, "concatenateArrayBuffers", {
   enumerable: true,
   get: function get() {
-    return _parseWithWorker.parseWithWorker;
+    return _arrayBufferUtils.concatenateArrayBuffers;
   }
 });
-Object.defineProperty(exports, "canParseWithWorker", {
+Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
   enumerable: true,
   get: function get() {
-    return _parseWithWorker.canParseWithWorker;
+    return _asyncIteration.concatenateArrayBuffersAsync;
   }
 });
-Object.defineProperty(exports, "canEncodeWithWorker", {
+Object.defineProperty(exports, "concatenateTypedArrays", {
   enumerable: true,
   get: function get() {
-    return _encodeWithWorker.canEncodeWithWorker;
+    return _arrayBufferUtils.concatenateTypedArrays;
   }
 });
-Object.defineProperty(exports, "parseJSON", {
+Object.defineProperty(exports, "copyArrayBuffer", {
   enumerable: true,
   get: function get() {
-    return _parseJson.parseJSON;
+    return _memoryCopyUtils.copyArrayBuffer;
   }
 });
-Object.defineProperty(exports, "toArrayBuffer", {
+Object.defineProperty(exports, "copyBinaryToDataView", {
   enumerable: true,
   get: function get() {
-    return _arrayBufferUtils.toArrayBuffer;
+    return _encodeUtils.copyBinaryToDataView;
   }
 });
-Object.defineProperty(exports, "sliceArrayBuffer", {
+Object.defineProperty(exports, "copyPaddedArrayBufferToDataView", {
   enumerable: true,
   get: function get() {
-    return _arrayBufferUtils.sliceArrayBuffer;
+    return _binaryCopyUtils.copyPaddedArrayBufferToDataView;
   }
 });
-Object.defineProperty(exports, "concatenateArrayBuffers", {
+Object.defineProperty(exports, "copyPaddedStringToDataView", {
   enumerable: true,
   get: function get() {
-    return _arrayBufferUtils.concatenateArrayBuffers;
+    return _binaryCopyUtils.copyPaddedStringToDataView;
   }
 });
-Object.defineProperty(exports, "concatenateTypedArrays", {
+Object.defineProperty(exports, "copyStringToDataView", {
   enumerable: true,
   get: function get() {
-    return _arrayBufferUtils.concatenateTypedArrays;
+    return _encodeUtils.copyStringToDataView;
   }
 });
-Object.defineProperty(exports, "compareArrayBuffers", {
+Object.defineProperty(exports, "copyToArray", {
   enumerable: true,
   get: function get() {
-    return _arrayBufferUtils.compareArrayBuffers;
+    return _memoryCopyUtils.copyToArray;
   }
 });
-Object.defineProperty(exports, "padToNBytes", {
+Object.defineProperty(exports, "createLoaderWorker", {
   enumerable: true,
   get: function get() {
-    return _memoryCopyUtils.padToNBytes;
+    return _createLoaderWorker.createLoaderWorker;
   }
 });
-Object.defineProperty(exports, "copyToArray", {
+Object.defineProperty(exports, "document", {
   enumerable: true,
   get: function get() {
-    return _memoryCopyUtils.copyToArray;
+    return _globals.document;
   }
 });
-Object.defineProperty(exports, "copyArrayBuffer", {
+Object.defineProperty(exports, "forEach", {
   enumerable: true,
   get: function get() {
-    return _memoryCopyUtils.copyArrayBuffer;
+    return _asyncIteration.forEach;
   }
 });
-Object.defineProperty(exports, "copyPaddedArrayBufferToDataView", {
+exports.fs = void 0;
+Object.defineProperty(exports, "getFirstCharacters", {
   enumerable: true,
   get: function get() {
-    return _binaryCopyUtils.copyPaddedArrayBufferToDataView;
+    return _getFirstCharacters.getFirstCharacters;
   }
 });
-Object.defineProperty(exports, "copyPaddedStringToDataView", {
+Object.defineProperty(exports, "getMagicString", {
   enumerable: true,
   get: function get() {
-    return _binaryCopyUtils.copyPaddedStringToDataView;
+    return _getFirstCharacters.getMagicString;
   }
 });
-Object.defineProperty(exports, "padStringToByteAlignment", {
+Object.defineProperty(exports, "getPathPrefix", {
   enumerable: true,
   get: function get() {
-    return _encodeUtils.padStringToByteAlignment;
+    return _fileAliases.getPathPrefix;
   }
 });
-Object.defineProperty(exports, "copyStringToDataView", {
+Object.defineProperty(exports, "global", {
   enumerable: true,
   get: function get() {
-    return _encodeUtils.copyStringToDataView;
+    return _globals.global;
   }
 });
-Object.defineProperty(exports, "copyBinaryToDataView", {
+Object.defineProperty(exports, "isBrowser", {
   enumerable: true,
   get: function get() {
-    return _encodeUtils.copyBinaryToDataView;
+    return _globals.isBrowser;
   }
 });
-Object.defineProperty(exports, "getFirstCharacters", {
+Object.defineProperty(exports, "isBuffer", {
   enumerable: true,
   get: function get() {
-    return _getFirstCharacters.getFirstCharacters;
+    return _bufferUtils.isBuffer;
   }
 });
-Object.defineProperty(exports, "getMagicString", {
+Object.defineProperty(exports, "isWorker", {
   enumerable: true,
   get: function get() {
-    return _getFirstCharacters.getMagicString;
+    return _globals.isWorker;
   }
 });
-Object.defineProperty(exports, "makeTextEncoderIterator", {
+Object.defineProperty(exports, "makeLineIterator", {
   enumerable: true,
   get: function get() {
-    return _textIterators.makeTextEncoderIterator;
+    return _textIterators.makeLineIterator;
+  }
+});
+Object.defineProperty(exports, "makeNumberedLineIterator", {
+  enumerable: true,
+  get: function get() {
+    return _textIterators.makeNumberedLineIterator;
   }
 });
 Object.defineProperty(exports, "makeTextDecoderIterator", {
@@ -187,147 +192,120 @@ Object.defineProperty(exports, "makeTextDecoderIterator", {
     return _textIterators.makeTextDecoderIterator;
   }
 });
-Object.defineProperty(exports, "makeLineIterator", {
+Object.defineProperty(exports, "makeTextEncoderIterator", {
   enumerable: true,
   get: function get() {
-    return _textIterators.makeLineIterator;
+    return _textIterators.makeTextEncoderIterator;
   }
 });
-Object.defineProperty(exports, "makeNumberedLineIterator", {
+Object.defineProperty(exports, "nodeVersion", {
   enumerable: true,
   get: function get() {
-    return _textIterators.makeNumberedLineIterator;
+    return _globals.nodeVersion;
   }
 });
-Object.defineProperty(exports, "forEach", {
+Object.defineProperty(exports, "padStringToByteAlignment", {
   enumerable: true,
   get: function get() {
-    return _asyncIteration.forEach;
+    return _encodeUtils.padStringToByteAlignment;
   }
 });
-Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
+Object.defineProperty(exports, "padToNBytes", {
   enumerable: true,
   get: function get() {
-    return _asyncIteration.concatenateArrayBuffersAsync;
+    return _memoryCopyUtils.padToNBytes;
   }
 });
-Object.defineProperty(exports, "RequestScheduler", {
+Object.defineProperty(exports, "parseJSON", {
   enumerable: true,
   get: function get() {
-    return _requestScheduler.default;
+    return _parseJson.parseJSON;
   }
 });
-Object.defineProperty(exports, "setPathPrefix", {
+Object.defineProperty(exports, "parseWithWorker", {
   enumerable: true,
   get: function get() {
-    return _fileAliases.setPathPrefix;
+    return _parseWithWorker.parseWithWorker;
   }
 });
-Object.defineProperty(exports, "getPathPrefix", {
+exports.path = void 0;
+Object.defineProperty(exports, "promisify1", {
   enumerable: true,
   get: function get() {
-    return _fileAliases.getPathPrefix;
+    return _util.promisify1;
   }
 });
-Object.defineProperty(exports, "resolvePath", {
+Object.defineProperty(exports, "promisify2", {
   enumerable: true,
   get: function get() {
-    return _fileAliases.resolvePath;
+    return _util.promisify2;
   }
 });
-Object.defineProperty(exports, "_addAliases", {
+Object.defineProperty(exports, "resolvePath", {
   enumerable: true,
   get: function get() {
-    return _fileAliases.addAliases;
+    return _fileAliases.resolvePath;
   }
 });
-Object.defineProperty(exports, "JSONLoader", {
+Object.defineProperty(exports, "self", {
   enumerable: true,
   get: function get() {
-    return _jsonLoader.JSONLoader;
+    return _globals.self;
   }
 });
-Object.defineProperty(exports, "isBuffer", {
+Object.defineProperty(exports, "setPathPrefix", {
   enumerable: true,
   get: function get() {
-    return _bufferUtils.isBuffer;
+    return _fileAliases.setPathPrefix;
   }
 });
-Object.defineProperty(exports, "toBuffer", {
+Object.defineProperty(exports, "sliceArrayBuffer", {
   enumerable: true,
   get: function get() {
-    return _bufferUtils.toBuffer;
+    return _arrayBufferUtils.sliceArrayBuffer;
   }
 });
-Object.defineProperty(exports, "bufferToArrayBuffer", {
+Object.defineProperty(exports, "toArrayBuffer", {
   enumerable: true,
   get: function get() {
-    return _bufferUtils.bufferToArrayBuffer;
+    return _arrayBufferUtils.toArrayBuffer;
   }
 });
-Object.defineProperty(exports, "promisify", {
+Object.defineProperty(exports, "toBuffer", {
   enumerable: true,
   get: function get() {
-    return util.promisify;
+    return _bufferUtils.toBuffer;
   }
 });
-Object.defineProperty(exports, "_NodeFileSystem", {
+Object.defineProperty(exports, "window", {
   enumerable: true,
   get: function get() {
-    return _nodeFilesystem.default;
+    return _globals.window;
   }
 });
-exports.fs = exports.util = exports.path = void 0;
-
 var _assert = require("./lib/env-utils/assert");
-
 var _globals = require("./lib/env-utils/globals");
-
 var _createLoaderWorker = require("./lib/worker-loader-utils/create-loader-worker");
-
 var _parseWithWorker = require("./lib/worker-loader-utils/parse-with-worker");
-
 var _encodeWithWorker = require("./lib/worker-loader-utils/encode-with-worker");
-
 var _parseJson = require("./lib/parser-utils/parse-json");
-
 var _arrayBufferUtils = require("./lib/binary-utils/array-buffer-utils");
-
 var _memoryCopyUtils = require("./lib/binary-utils/memory-copy-utils");
-
 var _binaryCopyUtils = require("./lib/binary-utils/binary-copy-utils");
-
 var _encodeUtils = require("./lib/binary-utils/encode-utils");
-
 var _getFirstCharacters = require("./lib/binary-utils/get-first-characters");
-
 var _textIterators = require("./lib/iterators/text-iterators");
-
 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 _bufferUtils = require("./lib/binary-utils/buffer-utils");
-
-var util = _interopRequireWildcard(require("./lib/node/util"));
-
-exports.util = util;
-
+var _util = require("./lib/node/util");
 var fs = _interopRequireWildcard(require("./lib/node/fs"));
-
 exports.fs = fs;
-
 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 _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;;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';\nexport {canEncodeWithWorker} from './lib/worker-loader-utils/encode-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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"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';\nexport {canEncodeWithWorker} from './lib/worker-loader-utils/encode-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' to avoid node dependencies\nexport {promisify1, promisify2} from './lib/node/util';\n\n// Use instead of importing 'fs' to avoid node dependencies`\nimport * as fs from './lib/node/fs';\nexport {fs};\n\n// EXPERIMENTAL\nexport {default as _NodeFileSystem} from './lib/filesystems/node-filesystem';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA;AACA;AAWA;AACA;AACA;AAGA;AAGA;AAOA;AACA;AAIA;AAKA;AAGA;AAMA;AAGA;AAGA;AAIA;AAOA;AAA8C;AAI9C;AAKA;AAGA;AAAoC;AAIpC;AAA6E;AAAA"}

package/dist/es5/json-loader.js

@@ -1,17 +1,14 @@
 "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.3.0-alpha.11" !== 'undefined' ? "3.3.0-alpha.11" : 'latest';
 
-var VERSION = typeof "3.3.0-alpha.1" !== 'undefined' ? "3.3.0-alpha.1" : 'latest';
 var JSONLoader = {
   name: 'JSON',
   id: 'json',
@@ -29,7 +26,6 @@ var JSONLoader = {
           switch (_context.prev = _context.next) {
             case 0:
               return _context.abrupt("return", parseTextSync(new TextDecoder().decode(arrayBuffer)));
-
             case 1:
             case "end":
               return _context.stop();
@@ -37,21 +33,18 @@ var JSONLoader = {
         }
       }, _callee);
     }));
-
     function parse(_x) {
       return _parse.apply(this, arguments);
     }
-
     return parse;
   }(),
   options: {}
 };
-exports.JSONLoader = JSONLoader;
 
+exports.JSONLoader = JSONLoader;
 function parseTextSync(text) {
   return JSON.parse(text);
 }
-
 var _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,2BAAuB,WAAvB,qBAAmD,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,"file":"json-loader.js","names":["VERSION","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parseTextSync","parse","arrayBuffer","TextDecoder","decode","options","JSON","_typecheckJSONLoader"],"sources":["../../src/json-loader.ts"],"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"],"mappings":";;;;;;;;;AAIA,IAAMA,OAAO,GAAG,uBAAkB,KAAK,WAAW,sBAAiB,QAAQ;;AAMpE,IAAMC,UAAU,GAAG;EACxBC,IAAI,EAAE,MAAM;EACZC,EAAE,EAAE,MAAM;EACVC,MAAM,EAAE,MAAM;EACdC,OAAO,EAAEL,OAAO;EAChBM,UAAU,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC;EAC/BC,SAAS,EAAE,CAAC,kBAAkB,CAAC;EAC/BC,QAAQ,EAAE,MAAM;EAChBC,IAAI,EAAE,IAAI;EACVC,aAAa,EAAbA,aAAa;EACbC,KAAK;IAAA,uEAAE,iBAAOC,WAAW;MAAA;QAAA;UAAA;YAAA;cAAA,iCAAKF,aAAa,CAAC,IAAIG,WAAW,EAAE,CAACC,MAAM,CAACF,WAAW,CAAC,CAAC;YAAA;YAAA;cAAA;UAAA;QAAA;MAAA;IAAA;IAAA;MAAA;IAAA;IAAA;EAAA;EAClFG,OAAO,EAAE,CAAC;AACZ,CAAC;;AAAC;AAGF,SAASL,aAAa,CAACD,IAAI,EAAE;EAC3B,OAAOO,IAAI,CAACL,KAAK,CAACF,IAAI,CAAC;AACzB;AAEO,IAAMQ,oBAAsC,GAAGhB,UAAU;AAAC"}

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

@@ -1,31 +1,23 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.toArrayBuffer = toArrayBuffer;
 exports.compareArrayBuffers = compareArrayBuffers;
 exports.concatenateArrayBuffers = concatenateArrayBuffers;
 exports.concatenateTypedArrays = concatenateTypedArrays;
 exports.sliceArrayBuffer = sliceArrayBuffer;
-
+exports.toArrayBuffer = toArrayBuffer;
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
 var _bufferUtils = require("./buffer-utils");
-
 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; } } }; }
-
 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 _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 ((0, _bufferUtils.isBuffer)(data)) {
     return (0, _bufferUtils.bufferToArrayBuffer)(data);
   }
-
   if (data instanceof ArrayBuffer) {
     return data;
   }
@@ -34,10 +26,8 @@ function toArrayBuffer(data) {
     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);
@@ -47,26 +37,21 @@ function toArrayBuffer(data) {
   if (data && (0, _typeof2.default)(data) === 'object' && data._toArrayBuffer) {
     return data._toArrayBuffer();
   }
-
   throw new Error('toArrayBuffer');
 }
 
 function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
   byteLength = byteLength || arrayBuffer1.byteLength;
-
   if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
     return false;
   }
-
   var array1 = new Uint8Array(arrayBuffer1);
   var array2 = new Uint8Array(arrayBuffer2);
-
   for (var i = 0; i < array1.length; ++i) {
     if (array1[i] !== array2[i]) {
       return false;
     }
   }
-
   return true;
 }
 
@@ -74,31 +59,31 @@ function concatenateArrayBuffers() {
   for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
     sources[_key] = arguments[_key];
   }
-
   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 offset = 0;
   var _iterator = _createForOfIteratorHelper(sourceArrays),
-      _step;
-
+    _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();
   }
-
   return result.buffer;
 }
 
@@ -106,26 +91,21 @@ 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;
-
   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;
-
   for (var _i = 0, _arrays = arrays; _i < _arrays.length; _i++) {
     var array = _arrays[_i];
     result.set(array, offset);
     offset += array.length;
   }
-
   return result;
 }