npm - @loaders.gl/loader-utils - Versions diffs - 3.0.12 → 3.0.13 - Mend

@loaders.gl/loader-utils 3.0.12 → 3.0.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

package/dist/es5/index.js CHANGED Viewed

@@ -2,272 +2,270 @@
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 Object.defineProperty(exports, "assert", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _assert.assert;
   }
 });
 Object.defineProperty(exports, "isBrowser", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.isBrowser;
   }
 });
 Object.defineProperty(exports, "isWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.isWorker;
   }
 });
 Object.defineProperty(exports, "nodeVersion", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.nodeVersion;
   }
 });
 Object.defineProperty(exports, "self", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.self;
   }
 });
 Object.defineProperty(exports, "window", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.window;
   }
 });
 Object.defineProperty(exports, "global", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.global;
   }
 });
 Object.defineProperty(exports, "document", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _globals.document;
   }
 });
 Object.defineProperty(exports, "createLoaderWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _createLoaderWorker.createLoaderWorker;
   }
 });
 Object.defineProperty(exports, "parseWithWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _parseWithWorker.parseWithWorker;
   }
 });
 Object.defineProperty(exports, "canParseWithWorker", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _parseWithWorker.canParseWithWorker;
   }
 });
 Object.defineProperty(exports, "parseJSON", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _parseJson.parseJSON;
   }
 });
 Object.defineProperty(exports, "toArrayBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.toArrayBuffer;
   }
 });
 Object.defineProperty(exports, "sliceArrayBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.sliceArrayBuffer;
   }
 });
 Object.defineProperty(exports, "concatenateArrayBuffers", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.concatenateArrayBuffers;
   }
 });
 Object.defineProperty(exports, "concatenateTypedArrays", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.concatenateTypedArrays;
   }
 });
 Object.defineProperty(exports, "compareArrayBuffers", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _arrayBufferUtils.compareArrayBuffers;
   }
 });
 Object.defineProperty(exports, "padToNBytes", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryCopyUtils.padToNBytes;
   }
 });
 Object.defineProperty(exports, "copyToArray", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryCopyUtils.copyToArray;
   }
 });
 Object.defineProperty(exports, "copyArrayBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _memoryCopyUtils.copyArrayBuffer;
   }
 });
 Object.defineProperty(exports, "copyPaddedArrayBufferToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _binaryCopyUtils.copyPaddedArrayBufferToDataView;
   }
 });
 Object.defineProperty(exports, "copyPaddedStringToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _binaryCopyUtils.copyPaddedStringToDataView;
   }
 });
 Object.defineProperty(exports, "padStringToByteAlignment", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _encodeUtils.padStringToByteAlignment;
   }
 });
 Object.defineProperty(exports, "copyStringToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _encodeUtils.copyStringToDataView;
   }
 });
 Object.defineProperty(exports, "copyBinaryToDataView", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _encodeUtils.copyBinaryToDataView;
   }
 });
 Object.defineProperty(exports, "getFirstCharacters", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _getFirstCharacters.getFirstCharacters;
   }
 });
 Object.defineProperty(exports, "getMagicString", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _getFirstCharacters.getMagicString;
   }
 });
 Object.defineProperty(exports, "makeTextEncoderIterator", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _textIterators.makeTextEncoderIterator;
   }
 });
 Object.defineProperty(exports, "makeTextDecoderIterator", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _textIterators.makeTextDecoderIterator;
   }
 });
 Object.defineProperty(exports, "makeLineIterator", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _textIterators.makeLineIterator;
   }
 });
 Object.defineProperty(exports, "makeNumberedLineIterator", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _textIterators.makeNumberedLineIterator;
   }
 });
 Object.defineProperty(exports, "forEach", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _asyncIteration.forEach;
   }
 });
 Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _asyncIteration.concatenateArrayBuffersAsync;
   }
 });
 Object.defineProperty(exports, "RequestScheduler", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _requestScheduler.default;
   }
 });
 Object.defineProperty(exports, "setPathPrefix", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.setPathPrefix;
   }
 });
 Object.defineProperty(exports, "getPathPrefix", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.getPathPrefix;
   }
 });
 Object.defineProperty(exports, "resolvePath", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.resolvePath;
   }
 });
 Object.defineProperty(exports, "_addAliases", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileAliases.addAliases;
   }
 });
 Object.defineProperty(exports, "JSONLoader", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _jsonLoader.JSONLoader;
   }
 });
 Object.defineProperty(exports, "isBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _bufferUtils.isBuffer;
   }
 });
 Object.defineProperty(exports, "toBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _bufferUtils.toBuffer;
   }
 });
 Object.defineProperty(exports, "bufferToArrayBuffer", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _bufferUtils.bufferToArrayBuffer;
   }
 });
 Object.defineProperty(exports, "promisify", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return util.promisify;
   }
 });
 Object.defineProperty(exports, "_NodeFileSystem", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _nodeFilesystem.default;
   }
 });
@@ -319,7 +317,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 _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map CHANGED Viewed

	@@ -1 +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"}
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"}

package/dist/es5/json-loader.js CHANGED Viewed

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

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

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

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

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

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

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

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

@@ -9,15 +9,15 @@ exports.copyPaddedStringToDataView = copyPaddedStringToDataView;
 var _memoryCopyUtils = require("./memory-copy-utils");
 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);
     }
   }
@@ -27,8 +27,8 @@ function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, pad
 }
 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;
 }