@loaders.gl/loader-utils 3.1.0-alpha.3 → 3.1.0-alpha.4

package/dist/es5/index.js

@@ -0,0 +1,325 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "assert", {
+  enumerable: true,
+  get: function get() {
+    return _assert.assert;
+  }
+});
+Object.defineProperty(exports, "isBrowser", {
+  enumerable: true,
+  get: function get() {
+    return _globals.isBrowser;
+  }
+});
+Object.defineProperty(exports, "isWorker", {
+  enumerable: true,
+  get: function get() {
+    return _globals.isWorker;
+  }
+});
+Object.defineProperty(exports, "nodeVersion", {
+  enumerable: true,
+  get: function get() {
+    return _globals.nodeVersion;
+  }
+});
+Object.defineProperty(exports, "self", {
+  enumerable: true,
+  get: function get() {
+    return _globals.self;
+  }
+});
+Object.defineProperty(exports, "window", {
+  enumerable: true,
+  get: function get() {
+    return _globals.window;
+  }
+});
+Object.defineProperty(exports, "global", {
+  enumerable: true,
+  get: function get() {
+    return _globals.global;
+  }
+});
+Object.defineProperty(exports, "document", {
+  enumerable: true,
+  get: function get() {
+    return _globals.document;
+  }
+});
+Object.defineProperty(exports, "createLoaderWorker", {
+  enumerable: true,
+  get: function get() {
+    return _createLoaderWorker.createLoaderWorker;
+  }
+});
+Object.defineProperty(exports, "parseWithWorker", {
+  enumerable: true,
+  get: function get() {
+    return _parseWithWorker.parseWithWorker;
+  }
+});
+Object.defineProperty(exports, "canParseWithWorker", {
+  enumerable: true,
+  get: function get() {
+    return _parseWithWorker.canParseWithWorker;
+  }
+});
+Object.defineProperty(exports, "parseJSON", {
+  enumerable: true,
+  get: function get() {
+    return _parseJson.parseJSON;
+  }
+});
+Object.defineProperty(exports, "toArrayBuffer", {
+  enumerable: true,
+  get: function get() {
+    return _arrayBufferUtils.toArrayBuffer;
+  }
+});
+Object.defineProperty(exports, "sliceArrayBuffer", {
+  enumerable: true,
+  get: function get() {
+    return _arrayBufferUtils.sliceArrayBuffer;
+  }
+});
+Object.defineProperty(exports, "concatenateArrayBuffers", {
+  enumerable: true,
+  get: function get() {
+    return _arrayBufferUtils.concatenateArrayBuffers;
+  }
+});
+Object.defineProperty(exports, "concatenateTypedArrays", {
+  enumerable: true,
+  get: function get() {
+    return _arrayBufferUtils.concatenateTypedArrays;
+  }
+});
+Object.defineProperty(exports, "compareArrayBuffers", {
+  enumerable: true,
+  get: function get() {
+    return _arrayBufferUtils.compareArrayBuffers;
+  }
+});
+Object.defineProperty(exports, "padToNBytes", {
+  enumerable: true,
+  get: function get() {
+    return _memoryCopyUtils.padToNBytes;
+  }
+});
+Object.defineProperty(exports, "copyToArray", {
+  enumerable: true,
+  get: function get() {
+    return _memoryCopyUtils.copyToArray;
+  }
+});
+Object.defineProperty(exports, "copyArrayBuffer", {
+  enumerable: true,
+  get: function get() {
+    return _memoryCopyUtils.copyArrayBuffer;
+  }
+});
+Object.defineProperty(exports, "copyPaddedArrayBufferToDataView", {
+  enumerable: true,
+  get: function get() {
+    return _binaryCopyUtils.copyPaddedArrayBufferToDataView;
+  }
+});
+Object.defineProperty(exports, "copyPaddedStringToDataView", {
+  enumerable: true,
+  get: function get() {
+    return _binaryCopyUtils.copyPaddedStringToDataView;
+  }
+});
+Object.defineProperty(exports, "padStringToByteAlignment", {
+  enumerable: true,
+  get: function get() {
+    return _encodeUtils.padStringToByteAlignment;
+  }
+});
+Object.defineProperty(exports, "copyStringToDataView", {
+  enumerable: true,
+  get: function get() {
+    return _encodeUtils.copyStringToDataView;
+  }
+});
+Object.defineProperty(exports, "copyBinaryToDataView", {
+  enumerable: true,
+  get: function get() {
+    return _encodeUtils.copyBinaryToDataView;
+  }
+});
+Object.defineProperty(exports, "getFirstCharacters", {
+  enumerable: true,
+  get: function get() {
+    return _getFirstCharacters.getFirstCharacters;
+  }
+});
+Object.defineProperty(exports, "getMagicString", {
+  enumerable: true,
+  get: function get() {
+    return _getFirstCharacters.getMagicString;
+  }
+});
+Object.defineProperty(exports, "makeTextEncoderIterator", {
+  enumerable: true,
+  get: function get() {
+    return _textIterators.makeTextEncoderIterator;
+  }
+});
+Object.defineProperty(exports, "makeTextDecoderIterator", {
+  enumerable: true,
+  get: function get() {
+    return _textIterators.makeTextDecoderIterator;
+  }
+});
+Object.defineProperty(exports, "makeLineIterator", {
+  enumerable: true,
+  get: function get() {
+    return _textIterators.makeLineIterator;
+  }
+});
+Object.defineProperty(exports, "makeNumberedLineIterator", {
+  enumerable: true,
+  get: function get() {
+    return _textIterators.makeNumberedLineIterator;
+  }
+});
+Object.defineProperty(exports, "forEach", {
+  enumerable: true,
+  get: function get() {
+    return _asyncIteration.forEach;
+  }
+});
+Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
+  enumerable: true,
+  get: function get() {
+    return _asyncIteration.concatenateArrayBuffersAsync;
+  }
+});
+Object.defineProperty(exports, "RequestScheduler", {
+  enumerable: true,
+  get: function get() {
+    return _requestScheduler.default;
+  }
+});
+Object.defineProperty(exports, "setPathPrefix", {
+  enumerable: true,
+  get: function get() {
+    return _fileAliases.setPathPrefix;
+  }
+});
+Object.defineProperty(exports, "getPathPrefix", {
+  enumerable: true,
+  get: function get() {
+    return _fileAliases.getPathPrefix;
+  }
+});
+Object.defineProperty(exports, "resolvePath", {
+  enumerable: true,
+  get: function get() {
+    return _fileAliases.resolvePath;
+  }
+});
+Object.defineProperty(exports, "_addAliases", {
+  enumerable: true,
+  get: function get() {
+    return _fileAliases.addAliases;
+  }
+});
+Object.defineProperty(exports, "JSONLoader", {
+  enumerable: true,
+  get: function get() {
+    return _jsonLoader.JSONLoader;
+  }
+});
+Object.defineProperty(exports, "isBuffer", {
+  enumerable: true,
+  get: function get() {
+    return _bufferUtils.isBuffer;
+  }
+});
+Object.defineProperty(exports, "toBuffer", {
+  enumerable: true,
+  get: function get() {
+    return _bufferUtils.toBuffer;
+  }
+});
+Object.defineProperty(exports, "bufferToArrayBuffer", {
+  enumerable: true,
+  get: function get() {
+    return _bufferUtils.bufferToArrayBuffer;
+  }
+});
+Object.defineProperty(exports, "promisify", {
+  enumerable: true,
+  get: function get() {
+    return util.promisify;
+  }
+});
+Object.defineProperty(exports, "_NodeFileSystem", {
+  enumerable: true,
+  get: function get() {
+    return _nodeFilesystem.default;
+  }
+});
+exports.fs = exports.util = exports.path = void 0;
+
+var _assert = require("./lib/env-utils/assert");
+
+var _globals = require("./lib/env-utils/globals");
+
+var _createLoaderWorker = require("./lib/worker-loader-utils/create-loader-worker");
+
+var _parseWithWorker = require("./lib/worker-loader-utils/parse-with-worker");
+
+var _parseJson = require("./lib/parser-utils/parse-json");
+
+var _arrayBufferUtils = require("./lib/binary-utils/array-buffer-utils");
+
+var _memoryCopyUtils = require("./lib/binary-utils/memory-copy-utils");
+
+var _binaryCopyUtils = require("./lib/binary-utils/binary-copy-utils");
+
+var _encodeUtils = require("./lib/binary-utils/encode-utils");
+
+var _getFirstCharacters = require("./lib/binary-utils/get-first-characters");
+
+var _textIterators = require("./lib/iterators/text-iterators");
+
+var _asyncIteration = require("./lib/iterators/async-iteration");
+
+var _requestScheduler = _interopRequireDefault(require("./lib/request-utils/request-scheduler"));
+
+var _fileAliases = require("./lib/path-utils/file-aliases");
+
+var _jsonLoader = require("./json-loader");
+
+var path = _interopRequireWildcard(require("./lib/path-utils/path"));
+
+exports.path = path;
+
+var _bufferUtils = require("./lib/binary-utils/buffer-utils");
+
+var util = _interopRequireWildcard(require("./lib/node/util"));
+
+exports.util = util;
+
+var fs = _interopRequireWildcard(require("./lib/node/fs"));
+
+exports.fs = fs;
+
+var _nodeFilesystem = _interopRequireDefault(require("./lib/filesystems/node-filesystem"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -0,0 +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

@@ -0,0 +1,57 @@
+"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.1.0-alpha.4" !== 'undefined' ? "3.1.0-alpha.4" : 'latest';
+var JSONLoader = {
+  name: 'JSON',
+  id: 'json',
+  module: 'json',
+  version: VERSION,
+  extensions: ['json', 'geojson'],
+  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;
+  }(),
+  options: {}
+};
+exports.JSONLoader = JSONLoader;
+
+function parseTextSync(text) {
+  return JSON.parse(text);
+}
+
+var _typecheckJSONLoader = JSONLoader;
+exports._typecheckJSONLoader = _typecheckJSONLoader;
+//# sourceMappingURL=json-loader.js.map

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

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

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

@@ -0,0 +1,137 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toArrayBuffer = toArrayBuffer;
+exports.compareArrayBuffers = compareArrayBuffers;
+exports.concatenateArrayBuffers = concatenateArrayBuffers;
+exports.concatenateTypedArrays = concatenateTypedArrays;
+exports.sliceArrayBuffer = sliceArrayBuffer;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _bufferUtils = require("./buffer-utils");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function toArrayBuffer(data) {
+  if ((0, _bufferUtils.isBuffer)(data)) {
+    return (0, _bufferUtils.bufferToArrayBuffer)(data);
+  }
+
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+
+  if (ArrayBuffer.isView(data)) {
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+      return data.buffer;
+    }
+
+    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  }
+
+  if (typeof data === 'string') {
+    var text = data;
+    var uint8Array = new TextEncoder().encode(text);
+    return uint8Array.buffer;
+  }
+
+  if (data && (0, _typeof2.default)(data) === 'object' && data._toArrayBuffer) {
+    return data._toArrayBuffer();
+  }
+
+  throw new Error('toArrayBuffer');
+}
+
+function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
+  byteLength = byteLength || arrayBuffer1.byteLength;
+
+  if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
+    return false;
+  }
+
+  var array1 = new Uint8Array(arrayBuffer1);
+  var array2 = new Uint8Array(arrayBuffer2);
+
+  for (var i = 0; i < array1.length; ++i) {
+    if (array1[i] !== array2[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+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();
+  }
+
+  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;
+
+  if (!TypedArrayConstructor) {
+    throw new Error('"concatenateTypedArrays" - incorrect quantity of arguments or arguments have incompatible data types');
+  }
+
+  var sumLength = arrays.reduce(function (acc, value) {
+    return acc + value.length;
+  }, 0);
+  var result = new TypedArrayConstructor(sumLength);
+  var offset = 0;
+
+  for (var _i = 0, _arrays = arrays; _i < _arrays.length; _i++) {
+    var array = _arrays[_i];
+    result.set(array, offset);
+    offset += array.length;
+  }
+
+  return result;
+}
+
+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);
+  return arrayCopy.buffer;
+}
+//# sourceMappingURL=array-buffer-utils.js.map