@loaders.gl/loader-utils 3.1.0-beta.4 → 3.1.0

package/dist/es5/index.js

@@ -2,270 +2,272 @@
 
 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: function get() {
     return _assert.assert;
   }
 });
 Object.defineProperty(exports, "isBrowser", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _globals.isBrowser;
   }
 });
 Object.defineProperty(exports, "isWorker", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _globals.isWorker;
   }
 });
 Object.defineProperty(exports, "nodeVersion", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _globals.nodeVersion;
   }
 });
 Object.defineProperty(exports, "self", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _globals.self;
   }
 });
 Object.defineProperty(exports, "window", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _globals.window;
   }
 });
 Object.defineProperty(exports, "global", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _globals.global;
   }
 });
 Object.defineProperty(exports, "document", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _globals.document;
   }
 });
 Object.defineProperty(exports, "createLoaderWorker", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _createLoaderWorker.createLoaderWorker;
   }
 });
 Object.defineProperty(exports, "parseWithWorker", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _parseWithWorker.parseWithWorker;
   }
 });
 Object.defineProperty(exports, "canParseWithWorker", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _parseWithWorker.canParseWithWorker;
   }
 });
 Object.defineProperty(exports, "parseJSON", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _parseJson.parseJSON;
   }
 });
 Object.defineProperty(exports, "toArrayBuffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _arrayBufferUtils.toArrayBuffer;
   }
 });
 Object.defineProperty(exports, "sliceArrayBuffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _arrayBufferUtils.sliceArrayBuffer;
   }
 });
 Object.defineProperty(exports, "concatenateArrayBuffers", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _arrayBufferUtils.concatenateArrayBuffers;
   }
 });
 Object.defineProperty(exports, "concatenateTypedArrays", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _arrayBufferUtils.concatenateTypedArrays;
   }
 });
 Object.defineProperty(exports, "compareArrayBuffers", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _arrayBufferUtils.compareArrayBuffers;
   }
 });
 Object.defineProperty(exports, "padToNBytes", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _memoryCopyUtils.padToNBytes;
   }
 });
 Object.defineProperty(exports, "copyToArray", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _memoryCopyUtils.copyToArray;
   }
 });
 Object.defineProperty(exports, "copyArrayBuffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _memoryCopyUtils.copyArrayBuffer;
   }
 });
 Object.defineProperty(exports, "copyPaddedArrayBufferToDataView", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _binaryCopyUtils.copyPaddedArrayBufferToDataView;
   }
 });
 Object.defineProperty(exports, "copyPaddedStringToDataView", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _binaryCopyUtils.copyPaddedStringToDataView;
   }
 });
 Object.defineProperty(exports, "padStringToByteAlignment", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _encodeUtils.padStringToByteAlignment;
   }
 });
 Object.defineProperty(exports, "copyStringToDataView", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _encodeUtils.copyStringToDataView;
   }
 });
 Object.defineProperty(exports, "copyBinaryToDataView", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _encodeUtils.copyBinaryToDataView;
   }
 });
 Object.defineProperty(exports, "getFirstCharacters", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _getFirstCharacters.getFirstCharacters;
   }
 });
 Object.defineProperty(exports, "getMagicString", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _getFirstCharacters.getMagicString;
   }
 });
 Object.defineProperty(exports, "makeTextEncoderIterator", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _textIterators.makeTextEncoderIterator;
   }
 });
 Object.defineProperty(exports, "makeTextDecoderIterator", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _textIterators.makeTextDecoderIterator;
   }
 });
 Object.defineProperty(exports, "makeLineIterator", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _textIterators.makeLineIterator;
   }
 });
 Object.defineProperty(exports, "makeNumberedLineIterator", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _textIterators.makeNumberedLineIterator;
   }
 });
 Object.defineProperty(exports, "forEach", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _asyncIteration.forEach;
   }
 });
 Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _asyncIteration.concatenateArrayBuffersAsync;
   }
 });
 Object.defineProperty(exports, "RequestScheduler", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _requestScheduler.default;
   }
 });
 Object.defineProperty(exports, "setPathPrefix", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _fileAliases.setPathPrefix;
   }
 });
 Object.defineProperty(exports, "getPathPrefix", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _fileAliases.getPathPrefix;
   }
 });
 Object.defineProperty(exports, "resolvePath", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _fileAliases.resolvePath;
   }
 });
 Object.defineProperty(exports, "_addAliases", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _fileAliases.addAliases;
   }
 });
 Object.defineProperty(exports, "JSONLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _jsonLoader.JSONLoader;
   }
 });
 Object.defineProperty(exports, "isBuffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _bufferUtils.isBuffer;
   }
 });
 Object.defineProperty(exports, "toBuffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _bufferUtils.toBuffer;
   }
 });
 Object.defineProperty(exports, "bufferToArrayBuffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _bufferUtils.bufferToArrayBuffer;
   }
 });
 Object.defineProperty(exports, "promisify", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return util.promisify;
   }
 });
 Object.defineProperty(exports, "_NodeFileSystem", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _nodeFilesystem.default;
   }
 });
@@ -317,7 +319,7 @@ 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 (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 _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 _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;;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"}
+{"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,11 +1,18 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports._typecheckJSONLoader = exports.JSONLoader = void 0;
-const VERSION = typeof "3.1.0-beta.4" !== 'undefined' ? "3.1.0-beta.4" : 'latest';
-const JSONLoader = {
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var VERSION = typeof "3.1.0" !== 'undefined' ? "3.1.0" : 'latest';
+var JSONLoader = {
   name: 'JSON',
   id: 'json',
   module: 'json',
@@ -14,8 +21,29 @@ const JSONLoader = {
   mimeTypes: ['application/json'],
   category: 'json',
   text: true,
-  parseTextSync,
-  parse: async arrayBuffer => parseTextSync(new TextDecoder().decode(arrayBuffer)),
+  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;
+  }(),
   options: {}
 };
 exports.JSONLoader = JSONLoader;
@@ -24,6 +52,6 @@ function parseTextSync(text) {
   return JSON.parse(text);
 }
 
-const _typecheckJSONLoader = JSONLoader;
+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,MAAMA,OAAO,GAAG,0BAAuB,WAAvB,oBAAmD,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"}
+{"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"}

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

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -9,8 +11,16 @@ exports.concatenateArrayBuffers = concatenateArrayBuffers;
 exports.concatenateTypedArrays = concatenateTypedArrays;
 exports.sliceArrayBuffer = sliceArrayBuffer;
 
+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);
@@ -29,12 +39,12 @@ function toArrayBuffer(data) {
   }
 
   if (typeof data === 'string') {
-    const text = data;
-    const uint8Array = new TextEncoder().encode(text);
+    var text = data;
+    var uint8Array = new TextEncoder().encode(text);
     return uint8Array.buffer;
   }
 
-  if (data && typeof data === 'object' && data._toArrayBuffer) {
+  if (data && (0, _typeof2.default)(data) === 'object' && data._toArrayBuffer) {
     return data._toArrayBuffer();
   }
 
@@ -48,10 +58,10 @@ function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
     return false;
   }
 
-  const array1 = new Uint8Array(arrayBuffer1);
-  const array2 = new Uint8Array(arrayBuffer2);
+  var array1 = new Uint8Array(arrayBuffer1);
+  var array2 = new Uint8Array(arrayBuffer2);
 
-  for (let i = 0; i < array1.length; ++i) {
+  for (var i = 0; i < array1.length; ++i) {
     if (array1[i] !== array2[i]) {
       return false;
     }
@@ -60,33 +70,58 @@ function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
   return true;
 }
 
-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;
+function concatenateArrayBuffers() {
+  for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
+    sources[_key] = arguments[_key];
+  }
 
-  for (const sourceArray of sourceArrays) {
-    result.set(sourceArray, offset);
-    offset += sourceArray.byteLength;
+  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();
   }
 
   return result.buffer;
 }
 
-function concatenateTypedArrays(...typedArrays) {
-  const arrays = typedArrays;
-  const TypedArrayConstructor = arrays && arrays.length > 1 && arrays[0].constructor || null;
+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');
   }
 
-  const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);
-  const result = new TypedArrayConstructor(sumLength);
-  let offset = 0;
+  var sumLength = arrays.reduce(function (acc, value) {
+    return acc + value.length;
+  }, 0);
+  var result = new TypedArrayConstructor(sumLength);
+  var offset = 0;
 
-  for (const array of arrays) {
+  for (var _i = 0, _arrays = arrays; _i < _arrays.length; _i++) {
+    var array = _arrays[_i];
     result.set(array, offset);
     offset += array.length;
   }
@@ -95,8 +130,8 @@ function concatenateTypedArrays(...typedArrays) {
 }
 
 function sliceArrayBuffer(arrayBuffer, byteOffset, byteLength) {
-  const subArray = byteLength !== undefined ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength) : new Uint8Array(arrayBuffer).subarray(byteOffset);
-  const arrayCopy = new Uint8Array(subArray);
+  var subArray = byteLength !== undefined ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength) : new Uint8Array(arrayBuffer).subarray(byteOffset);
+  var 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,"sources":["../../../../src/lib/binary-utils/array-buffer-utils.ts"],"names":["toArrayBuffer","data","ArrayBuffer","isView","byteOffset","byteLength","buffer","slice","text","uint8Array","TextEncoder","encode","_toArrayBuffer","Error","compareArrayBuffers","arrayBuffer1","arrayBuffer2","array1","Uint8Array","array2","i","length","concatenateArrayBuffers","sources","sourceArrays","map","source2","reduce","typedArray","result","offset","sourceArray","set","concatenateTypedArrays","typedArrays","arrays","TypedArrayConstructor","constructor","sumLength","acc","value","array","sliceArrayBuffer","arrayBuffer","subArray","undefined","subarray","arrayCopy"],"mappings":"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","sourcesContent":["import {TypedArray} from '../../types';\nimport {isBuffer, bufferToArrayBuffer} from './buffer-utils';\n\n/**\n * Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: any): ArrayBuffer {\n  // Note: Should be called first, Buffers can trigger other detections below\n  if (isBuffer(data)) {\n    return bufferToArrayBuffer(data);\n  }\n\n  if (data instanceof ArrayBuffer) {\n    return data;\n  }\n\n  // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)\n  if (ArrayBuffer.isView(data)) {\n    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {\n      return data.buffer;\n    }\n    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);\n  }\n\n  if (typeof data === 'string') {\n    const text = data;\n    const uint8Array = new TextEncoder().encode(text);\n    return uint8Array.buffer;\n  }\n\n  // HACK to support Blob polyfill\n  if (data && typeof data === 'object' && data._toArrayBuffer) {\n    return data._toArrayBuffer();\n  }\n\n  throw new Error('toArrayBuffer');\n}\n\n/**\n * compare two binary arrays for equality\n * @param {ArrayBuffer} a\n * @param {ArrayBuffer} b\n * @param {number} byteLength\n */\nexport function compareArrayBuffers(\n  arrayBuffer1: ArrayBuffer,\n  arrayBuffer2: ArrayBuffer,\n  byteLength?: number\n): boolean {\n  byteLength = byteLength || arrayBuffer1.byteLength;\n  if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {\n    return false;\n  }\n  const array1 = new Uint8Array(arrayBuffer1);\n  const array2 = new Uint8Array(arrayBuffer2);\n  for (let i = 0; i < array1.length; ++i) {\n    if (array1[i] !== array2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Concatenate a sequence of ArrayBuffers\n * @return A concatenated ArrayBuffer\n */\nexport function concatenateArrayBuffers(...sources: (ArrayBuffer | Uint8Array)[]): ArrayBuffer {\n  // Make sure all inputs are wrapped in typed arrays\n  const sourceArrays = sources.map((source2) =>\n    source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2\n  );\n\n  // Get length of all inputs\n  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);\n\n  // Allocate array with space for all inputs\n  const result = new Uint8Array(byteLength);\n\n  // Copy the subarrays\n  let offset = 0;\n  for (const sourceArray of sourceArrays) {\n    result.set(sourceArray, offset);\n    offset += sourceArray.byteLength;\n  }\n\n  // We work with ArrayBuffers, discard the typed array wrapper\n  return result.buffer;\n}\n\n/**\n * Concatenate arbitrary count of typed arrays\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays\n * @param {...*} arrays - list of arrays. All arrays should be the same type\n * @return A concatenated TypedArray\n */\nexport function concatenateTypedArrays<T>(...typedArrays: T[]): T {\n  // @ts-ignore\n  const arrays = typedArrays as TypedArray[];\n  // @ts-ignore\n  const TypedArrayConstructor = (arrays && arrays.length > 1 && arrays[0].constructor) || null;\n  if (!TypedArrayConstructor) {\n    throw new Error(\n      '\"concatenateTypedArrays\" - incorrect quantity of arguments or arguments have incompatible data types'\n    );\n  }\n\n  const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);\n  // @ts-ignore typescript does not like dynamic constructors\n  const result = new TypedArrayConstructor(sumLength);\n  let offset = 0;\n  for (const array of arrays) {\n    result.set(array, offset);\n    offset += array.length;\n  }\n  return result;\n}\n\n/**\n * Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0\n * @param arrayBuffer\n * @param byteOffset\n * @param byteLength\n */\nexport function sliceArrayBuffer(\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number,\n  byteLength?: number\n): ArrayBuffer {\n  const subArray =\n    byteLength !== undefined\n      ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength)\n      : new Uint8Array(arrayBuffer).subarray(byteOffset);\n  const arrayCopy = new Uint8Array(subArray);\n  return arrayCopy.buffer;\n}\n"],"file":"array-buffer-utils.js"}
+{"version":3,"sources":["../../../../src/lib/binary-utils/array-buffer-utils.ts"],"names":["toArrayBuffer","data","ArrayBuffer","isView","byteOffset","byteLength","buffer","slice","text","uint8Array","TextEncoder","encode","_toArrayBuffer","Error","compareArrayBuffers","arrayBuffer1","arrayBuffer2","array1","Uint8Array","array2","i","length","concatenateArrayBuffers","sources","sourceArrays","map","source2","reduce","typedArray","result","offset","sourceArray","set","concatenateTypedArrays","typedArrays","arrays","TypedArrayConstructor","constructor","sumLength","acc","value","array","sliceArrayBuffer","arrayBuffer","subArray","undefined","subarray","arrayCopy"],"mappings":"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","sourcesContent":["import {TypedArray} from '../../types';\nimport {isBuffer, bufferToArrayBuffer} from './buffer-utils';\n\n/**\n * Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: any): ArrayBuffer {\n  // Note: Should be called first, Buffers can trigger other detections below\n  if (isBuffer(data)) {\n    return bufferToArrayBuffer(data);\n  }\n\n  if (data instanceof ArrayBuffer) {\n    return data;\n  }\n\n  // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)\n  if (ArrayBuffer.isView(data)) {\n    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {\n      return data.buffer;\n    }\n    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);\n  }\n\n  if (typeof data === 'string') {\n    const text = data;\n    const uint8Array = new TextEncoder().encode(text);\n    return uint8Array.buffer;\n  }\n\n  // HACK to support Blob polyfill\n  if (data && typeof data === 'object' && data._toArrayBuffer) {\n    return data._toArrayBuffer();\n  }\n\n  throw new Error('toArrayBuffer');\n}\n\n/**\n * compare two binary arrays for equality\n * @param {ArrayBuffer} a\n * @param {ArrayBuffer} b\n * @param {number} byteLength\n */\nexport function compareArrayBuffers(\n  arrayBuffer1: ArrayBuffer,\n  arrayBuffer2: ArrayBuffer,\n  byteLength?: number\n): boolean {\n  byteLength = byteLength || arrayBuffer1.byteLength;\n  if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {\n    return false;\n  }\n  const array1 = new Uint8Array(arrayBuffer1);\n  const array2 = new Uint8Array(arrayBuffer2);\n  for (let i = 0; i < array1.length; ++i) {\n    if (array1[i] !== array2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Concatenate a sequence of ArrayBuffers\n * @return A concatenated ArrayBuffer\n */\nexport function concatenateArrayBuffers(...sources: (ArrayBuffer | Uint8Array)[]): ArrayBuffer {\n  // Make sure all inputs are wrapped in typed arrays\n  const sourceArrays = sources.map((source2) =>\n    source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2\n  );\n\n  // Get length of all inputs\n  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);\n\n  // Allocate array with space for all inputs\n  const result = new Uint8Array(byteLength);\n\n  // Copy the subarrays\n  let offset = 0;\n  for (const sourceArray of sourceArrays) {\n    result.set(sourceArray, offset);\n    offset += sourceArray.byteLength;\n  }\n\n  // We work with ArrayBuffers, discard the typed array wrapper\n  return result.buffer;\n}\n\n/**\n * Concatenate arbitrary count of typed arrays\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays\n * @param {...*} arrays - list of arrays. All arrays should be the same type\n * @return A concatenated TypedArray\n */\nexport function concatenateTypedArrays<T>(...typedArrays: T[]): T {\n  // @ts-ignore\n  const arrays = typedArrays as TypedArray[];\n  // @ts-ignore\n  const TypedArrayConstructor = (arrays && arrays.length > 1 && arrays[0].constructor) || null;\n  if (!TypedArrayConstructor) {\n    throw new Error(\n      '\"concatenateTypedArrays\" - incorrect quantity of arguments or arguments have incompatible data types'\n    );\n  }\n\n  const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);\n  // @ts-ignore typescript does not like dynamic constructors\n  const result = new TypedArrayConstructor(sumLength);\n  let offset = 0;\n  for (const array of arrays) {\n    result.set(array, offset);\n    offset += array.length;\n  }\n  return result;\n}\n\n/**\n * Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0\n * @param arrayBuffer\n * @param byteOffset\n * @param byteLength\n */\nexport function sliceArrayBuffer(\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number,\n  byteLength?: number\n): ArrayBuffer {\n  const subArray =\n    byteLength !== undefined\n      ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength)\n      : new Uint8Array(arrayBuffer).subarray(byteOffset);\n  const arrayCopy = new Uint8Array(subArray);\n  return arrayCopy.buffer;\n}\n"],"file":"array-buffer-utils.js"}

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

@@ -9,15 +9,15 @@ exports.copyPaddedStringToDataView = copyPaddedStringToDataView;
 var _memoryCopyUtils = require("./memory-copy-utils");
 
 function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
-  const paddedLength = (0, _memoryCopyUtils.padToNBytes)(sourceBuffer.byteLength, padding);
-  const padLength = paddedLength - sourceBuffer.byteLength;
+  var paddedLength = (0, _memoryCopyUtils.padToNBytes)(sourceBuffer.byteLength, padding);
+  var padLength = paddedLength - sourceBuffer.byteLength;
 
   if (dataView) {
-    const targetArray = new Uint8Array(dataView.buffer, dataView.byteOffset + byteOffset, sourceBuffer.byteLength);
-    const sourceArray = new Uint8Array(sourceBuffer);
+    var targetArray = new Uint8Array(dataView.buffer, dataView.byteOffset + byteOffset, sourceBuffer.byteLength);
+    var sourceArray = new Uint8Array(sourceBuffer);
     targetArray.set(sourceArray);
 
-    for (let i = 0; i < padLength; ++i) {
+    for (var i = 0; i < padLength; ++i) {
       dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 0x20);
     }
   }
@@ -27,8 +27,8 @@ function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, pad
 }
 
 function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
-  const textEncoder = new TextEncoder();
-  const stringBuffer = textEncoder.encode(string);
+  var textEncoder = new TextEncoder();
+  var stringBuffer = textEncoder.encode(string);
   byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
   return byteOffset;
 }