@loaders.gl/loader-utils 3.4.14 → 3.4.15

package/dist/es5/index.js

@@ -1,298 +1,297 @@
 "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, "JSONLoader", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _jsonLoader.JSONLoader;
   }
 });
 Object.defineProperty(exports, "RequestScheduler", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _requestScheduler.default;
   }
 });
 Object.defineProperty(exports, "_NodeFileSystem", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _nodeFilesystem.default;
   }
 });
 Object.defineProperty(exports, "_addAliases", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.addAliases;
   }
 });
 Object.defineProperty(exports, "assert", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _assert.assert;
   }
 });
 Object.defineProperty(exports, "canEncodeWithWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _encodeWithWorker.canEncodeWithWorker;
   }
 });
 Object.defineProperty(exports, "canParseWithWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _parseWithWorker.canParseWithWorker;
   }
 });
 Object.defineProperty(exports, "compareArrayBuffers", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.compareArrayBuffers;
   }
 });
 Object.defineProperty(exports, "concatenateArrayBuffers", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.concatenateArrayBuffers;
   }
 });
 Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _asyncIteration.concatenateArrayBuffersAsync;
   }
 });
 Object.defineProperty(exports, "concatenateTypedArrays", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.concatenateTypedArrays;
   }
 });
 Object.defineProperty(exports, "copyArrayBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryCopyUtils.copyArrayBuffer;
   }
 });
 Object.defineProperty(exports, "copyBinaryToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _dataviewCopyUtils.copyBinaryToDataView;
   }
 });
 Object.defineProperty(exports, "copyPaddedArrayBufferToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _dataviewCopyUtils.copyPaddedArrayBufferToDataView;
   }
 });
 Object.defineProperty(exports, "copyPaddedStringToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _dataviewCopyUtils.copyPaddedStringToDataView;
   }
 });
 Object.defineProperty(exports, "copyStringToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _dataviewCopyUtils.copyStringToDataView;
   }
 });
 Object.defineProperty(exports, "copyToArray", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryCopyUtils.copyToArray;
   }
 });
 Object.defineProperty(exports, "createLoaderWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _createLoaderWorker.createLoaderWorker;
   }
 });
 Object.defineProperty(exports, "document", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.document;
   }
 });
 Object.defineProperty(exports, "forEach", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _asyncIteration.forEach;
   }
 });
 exports.fs = void 0;
 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, "getPathPrefix", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.getPathPrefix;
   }
 });
 Object.defineProperty(exports, "global", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.global;
   }
 });
 Object.defineProperty(exports, "isBrowser", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.isBrowser;
   }
 });
 Object.defineProperty(exports, "isBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryConversionUtils.isBuffer;
   }
 });
 Object.defineProperty(exports, "isWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.isWorker;
   }
 });
 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, "makeReadableFile", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _readableFile.makeReadableFile;
   }
 });
 Object.defineProperty(exports, "makeTextDecoderIterator", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _textIterators.makeTextDecoderIterator;
   }
 });
 Object.defineProperty(exports, "makeTextEncoderIterator", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _textIterators.makeTextEncoderIterator;
   }
 });
 Object.defineProperty(exports, "makeWritableFile", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _writableFile.makeWritableFile;
   }
 });
 Object.defineProperty(exports, "mergeLoaderOptions", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _mergeLoaderOptions.mergeLoaderOptions;
   }
 });
 Object.defineProperty(exports, "nodeVersion", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.nodeVersion;
   }
 });
 Object.defineProperty(exports, "padStringToByteAlignment", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _dataviewCopyUtils.padStringToByteAlignment;
   }
 });
 Object.defineProperty(exports, "padToNBytes", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryCopyUtils.padToNBytes;
   }
 });
 Object.defineProperty(exports, "parseJSON", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _parseJson.parseJSON;
   }
 });
 Object.defineProperty(exports, "parseWithWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _parseWithWorker.parseWithWorker;
   }
 });
 exports.path = void 0;
 Object.defineProperty(exports, "promisify1", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _promisify.promisify1;
   }
 });
 Object.defineProperty(exports, "promisify2", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _promisify.promisify2;
   }
 });
 Object.defineProperty(exports, "resolvePath", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.resolvePath;
   }
 });
 Object.defineProperty(exports, "self", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.self;
   }
 });
 Object.defineProperty(exports, "setPathPrefix", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.setPathPrefix;
   }
 });
 Object.defineProperty(exports, "sliceArrayBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.sliceArrayBuffer;
   }
 });
 exports.stream = void 0;
 Object.defineProperty(exports, "toArrayBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryConversionUtils.toArrayBuffer;
   }
 });
 Object.defineProperty(exports, "toBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryConversionUtils.toBuffer;
   }
 });
 Object.defineProperty(exports, "window", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.window;
   }
 });
@@ -323,6 +322,6 @@ exports.stream = stream;
 var _readableFile = require("./lib/filesystems/readable-file");
 var _writableFile = require("./lib/filesystems/writable-file");
 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; }
+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; }
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_assert","require","_globals","_mergeLoaderOptions","_createLoaderWorker","_parseWithWorker","_encodeWithWorker","_parseJson","_arrayBufferUtils","_memoryCopyUtils","_dataviewCopyUtils","_getFirstCharacters","_textIterators","_asyncIteration","_requestScheduler","_interopRequireDefault","_fileAliases","_jsonLoader","_memoryConversionUtils","_promisify","path","_interopRequireWildcard","exports","fs","stream","_readableFile","_writableFile","_nodeFilesystem","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","_typeof","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set"],"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\nexport {mergeLoaderOptions} from './lib/option-utils/merge-loader-options';\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  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  padStringToByteAlignment,\n  copyStringToDataView,\n  copyBinaryToDataView,\n  copyPaddedArrayBufferToDataView,\n  copyPaddedStringToDataView\n} from './lib/binary-utils/dataview-copy-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// Avoid direct use of `Buffer` which pulls in 50KB polyfill\nexport {isBuffer, toBuffer, toArrayBuffer} from './lib/binary-utils/memory-conversion-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/promisify';\n\n// `path` replacement (avoids bundling big path polyfill)\nimport * as path from './lib/path-utils/path';\nexport {path};\n\n// Use instead of importing 'fs' to avoid node dependencies`\nimport * as fs from './lib/node/fs';\nexport {fs};\n\n// Use instead of importing 'stream' to avoid node dependencies`\nimport * as stream from './lib/node/stream';\nexport {stream};\n\n// EXPERIMENTAL\nexport type {ReadableFile} from './lib/filesystems/readable-file';\nexport {makeReadableFile} from './lib/filesystems/readable-file';\n\nexport type {WritableFile} from './lib/filesystems/writable-file';\nexport {makeWritableFile} from './lib/filesystems/writable-file';\n\nexport {default as _NodeFileSystem} from './lib/filesystems/node-filesystem';\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["_assert","require","_globals","_mergeLoaderOptions","_createLoaderWorker","_parseWithWorker","_encodeWithWorker","_parseJson","_arrayBufferUtils","_memoryCopyUtils","_dataviewCopyUtils","_getFirstCharacters","_textIterators","_asyncIteration","_requestScheduler","_interopRequireDefault","_fileAliases","_jsonLoader","_memoryConversionUtils","_promisify","path","_interopRequireWildcard","exports","fs","stream","_readableFile","_writableFile","_nodeFilesystem","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set"],"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\nexport {mergeLoaderOptions} from './lib/option-utils/merge-loader-options';\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  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  padStringToByteAlignment,\n  copyStringToDataView,\n  copyBinaryToDataView,\n  copyPaddedArrayBufferToDataView,\n  copyPaddedStringToDataView\n} from './lib/binary-utils/dataview-copy-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// Avoid direct use of `Buffer` which pulls in 50KB polyfill\nexport {isBuffer, toBuffer, toArrayBuffer} from './lib/binary-utils/memory-conversion-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/promisify';\n\n// `path` replacement (avoids bundling big path polyfill)\nimport * as path from './lib/path-utils/path';\nexport {path};\n\n// Use instead of importing 'fs' to avoid node dependencies`\nimport * as fs from './lib/node/fs';\nexport {fs};\n\n// Use instead of importing 'stream' to avoid node dependencies`\nimport * as stream from './lib/node/stream';\nexport {stream};\n\n// EXPERIMENTAL\nexport type {ReadableFile} from './lib/filesystems/readable-file';\nexport {makeReadableFile} from './lib/filesystems/readable-file';\n\nexport type {WritableFile} from './lib/filesystems/writable-file';\nexport {makeWritableFile} from './lib/filesystems/writable-file';\n\nexport {default as _NodeFileSystem} from './lib/filesystems/node-filesystem';\n"],"mappings":"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"}

package/dist/es5/json-loader.js

@@ -1,14 +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.4.14" !== 'undefined' ? "3.4.14" : 'latest';
-var JSONLoader = {
+const VERSION = typeof "3.4.15" !== 'undefined' ? "3.4.15" : 'latest';
+const JSONLoader = {
   name: 'JSON',
   id: 'json',
   module: 'json',
@@ -17,30 +14,14 @@ 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;
 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,"file":"json-loader.js","names":["VERSION","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parseTextSync","parse","_parse","_asyncToGenerator2","default","_regenerator","mark","_callee","arrayBuffer","wrap","_callee$","_context","prev","next","abrupt","TextDecoder","decode","stop","_x","apply","arguments","options","exports","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,eAAkB,KAAK,WAAW,cAAiB,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,IAAAC,MAAA,OAAAC,kBAAA,CAAAC,OAAA,EAAAC,YAAA,CAAAD,OAAA,CAAAE,IAAA,CAAE,SAAAC,QAAOC,WAAW;MAAA,OAAAH,YAAA,CAAAD,OAAA,CAAAK,IAAA,UAAAC,SAAAC,QAAA;QAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;UAAA;YAAA,OAAAF,QAAA,CAAAG,MAAA,WAAKd,aAAa,CAAC,IAAIe,WAAW,CAAC,CAAC,CAACC,MAAM,CAACR,WAAW,CAAC,CAAC;UAAA;UAAA;YAAA,OAAAG,QAAA,CAAAM,IAAA;QAAA;MAAA,GAAAV,OAAA;IAAA;IAAA,SAAAN,MAAAiB,EAAA;MAAA,OAAAhB,MAAA,CAAAiB,KAAA,OAAAC,SAAA;IAAA;IAAA,OAAAnB,KAAA;EAAA;EAClFoB,OAAO,EAAE,CAAC;AACZ,CAAC;AAACC,OAAA,CAAA/B,UAAA,GAAAA,UAAA;AAGF,SAASS,aAAaA,CAACD,IAAI,EAAE;EAC3B,OAAOwB,IAAI,CAACtB,KAAK,CAACF,IAAI,CAAC;AACzB;AAEO,IAAMyB,oBAAsC,GAAGjC,UAAU;AAAC+B,OAAA,CAAAE,oBAAA,GAAAA,oBAAA"}
+{"version":3,"file":"json-loader.js","names":["VERSION","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parseTextSync","parse","arrayBuffer","TextDecoder","decode","options","exports","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,MAAMA,OAAO,GAAG,eAAkB,KAAK,WAAW,cAAiB,QAAQ;AAMpE,MAAMC,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;EACbC,KAAK,EAAE,MAAOC,WAAW,IAAKF,aAAa,CAAC,IAAIG,WAAW,CAAC,CAAC,CAACC,MAAM,CAACF,WAAW,CAAC,CAAC;EAClFG,OAAO,EAAE,CAAC;AACZ,CAAC;AAACC,OAAA,CAAAf,UAAA,GAAAA,UAAA;AAGF,SAASS,aAAaA,CAACD,IAAI,EAAE;EAC3B,OAAOQ,IAAI,CAACN,KAAK,CAACF,IAAI,CAAC;AACzB;AAEO,MAAMS,oBAAsC,GAAGjB,UAAU;AAACe,OAAA,CAAAE,oBAAA,GAAAA,oBAAA"}

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

@@ -7,17 +7,14 @@ exports.compareArrayBuffers = compareArrayBuffers;
 exports.concatenateArrayBuffers = concatenateArrayBuffers;
 exports.concatenateTypedArrays = concatenateTypedArrays;
 exports.sliceArrayBuffer = sliceArrayBuffer;
-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 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) {
+  const array1 = new Uint8Array(arrayBuffer1);
+  const array2 = new Uint8Array(arrayBuffer2);
+  for (let i = 0; i < array1.length; ++i) {
     if (array1[i] !== array2[i]) {
       return false;
     }
@@ -28,26 +25,13 @@ 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 _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();
+  const sourceArrays = sources.map(source2 => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const sourceArray of sourceArrays) {
+    result.set(sourceArray, offset);
+    offset += sourceArray.byteLength;
   }
   return result.buffer;
 }
@@ -55,26 +39,23 @@ 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;
+  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;
-  for (var _i = 0, _arrays = arrays; _i < _arrays.length; _i++) {
-    var array = _arrays[_i];
+  const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);
+  const result = new TypedArrayConstructor(sumLength);
+  let offset = 0;
+  for (const array of arrays) {
     result.set(array, offset);
     offset += array.length;
   }
   return result;
 }
 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

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

@@ -1 +1 @@
-{"version":3,"file":"array-buffer-utils.js","names":["compareArrayBuffers","arrayBuffer1","arrayBuffer2","byteLength","array1","Uint8Array","array2","i","length","concatenateArrayBuffers","_len","arguments","sources","Array","_key","sourceArrays","map","source2","ArrayBuffer","reduce","typedArray","result","offset","_iterator","_createForOfIteratorHelper","_step","s","n","done","sourceArray","value","set","err","e","f","buffer","concatenateTypedArrays","_len2","typedArrays","_key2","arrays","TypedArrayConstructor","constructor","Error","sumLength","acc","_i","_arrays","array","sliceArrayBuffer","arrayBuffer","byteOffset","subArray","undefined","subarray","arrayCopy"],"sources":["../../../../src/lib/binary-utils/array-buffer-utils.ts"],"sourcesContent":["import {TypedArray} from '../../types';\n\n/**\n * compare two binary arrays for equality\n * @param a\n * @param b\n * @param 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 - 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"],"mappings":"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"}
+{"version":3,"file":"array-buffer-utils.js","names":["compareArrayBuffers","arrayBuffer1","arrayBuffer2","byteLength","array1","Uint8Array","array2","i","length","concatenateArrayBuffers","_len","arguments","sources","Array","_key","sourceArrays","map","source2","ArrayBuffer","reduce","typedArray","result","offset","sourceArray","set","buffer","concatenateTypedArrays","_len2","typedArrays","_key2","arrays","TypedArrayConstructor","constructor","Error","sumLength","acc","value","array","sliceArrayBuffer","arrayBuffer","byteOffset","subArray","undefined","subarray","arrayCopy"],"sources":["../../../../src/lib/binary-utils/array-buffer-utils.ts"],"sourcesContent":["import {TypedArray} from '../../types';\n\n/**\n * compare two binary arrays for equality\n * @param a\n * @param b\n * @param 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 - 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"],"mappings":"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"}

package/dist/es5/lib/binary-utils/dataview-copy-utils.js

@@ -10,18 +10,18 @@ exports.copyStringToDataView = copyStringToDataView;
 exports.padStringToByteAlignment = padStringToByteAlignment;
 var _memoryCopyUtils = require("./memory-copy-utils");
 function padStringToByteAlignment(string, byteAlignment) {
-  var length = string.length;
-  var paddedLength = Math.ceil(length / byteAlignment) * byteAlignment;
-  var padding = paddedLength - length;
-  var whitespace = '';
-  for (var i = 0; i < padding; ++i) {
+  const length = string.length;
+  const paddedLength = Math.ceil(length / byteAlignment) * byteAlignment;
+  const padding = paddedLength - length;
+  let whitespace = '';
+  for (let i = 0; i < padding; ++i) {
     whitespace += ' ';
   }
   return string + whitespace;
 }
 function copyStringToDataView(dataView, byteOffset, string, byteLength) {
   if (dataView) {
-    for (var i = 0; i < byteLength; i++) {
+    for (let i = 0; i < byteLength; i++) {
       dataView.setUint8(byteOffset + i, string.charCodeAt(i));
     }
   }
@@ -29,20 +29,20 @@ function copyStringToDataView(dataView, byteOffset, string, byteLength) {
 }
 function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {
   if (dataView) {
-    for (var i = 0; i < byteLength; i++) {
+    for (let i = 0; i < byteLength; i++) {
       dataView.setUint8(byteOffset + i, binary[i]);
     }
   }
   return byteOffset + byteLength;
 }
 function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
-  var paddedLength = (0, _memoryCopyUtils.padToNBytes)(sourceBuffer.byteLength, padding);
-  var padLength = paddedLength - sourceBuffer.byteLength;
+  const paddedLength = (0, _memoryCopyUtils.padToNBytes)(sourceBuffer.byteLength, padding);
+  const padLength = paddedLength - sourceBuffer.byteLength;
   if (dataView) {
-    var targetArray = new Uint8Array(dataView.buffer, dataView.byteOffset + byteOffset, sourceBuffer.byteLength);
-    var sourceArray = new Uint8Array(sourceBuffer);
+    const targetArray = new Uint8Array(dataView.buffer, dataView.byteOffset + byteOffset, sourceBuffer.byteLength);
+    const sourceArray = new Uint8Array(sourceBuffer);
     targetArray.set(sourceArray);
-    for (var i = 0; i < padLength; ++i) {
+    for (let i = 0; i < padLength; ++i) {
       dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 0x20);
     }
   }
@@ -50,8 +50,8 @@ function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, pad
   return byteOffset;
 }
 function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
-  var textEncoder = new TextEncoder();
-  var stringBuffer = textEncoder.encode(string);
+  const textEncoder = new TextEncoder();
+  const stringBuffer = textEncoder.encode(string);
   byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
   return byteOffset;
 }